Merge pull request #4979 from stacks-network/feat/finish-pass-argument-to-wasm

Clarity-Wasm: Implement "pass_argument_to_wasm" for remaining types

Author: csgui

clarity/src/vm/clarity_wasm.rs

@@ -20,8 +20,8 @@ use super::errors::RuntimeErrorType;
 use super::events::*;
 use super::functions::crypto::{pubkey_to_address_v1, pubkey_to_address_v2};
 use super::types::{
-    ASCIIData, AssetIdentifier, BlockInfoProperty, BuffData, BurnBlockInfoProperty, CharType,
-    FixedFunction, FunctionType, ListData, ListTypeData, OptionalData, PrincipalData,
+    ASCIIData, AssetIdentifier, BlockInfoProperty, BuffData, BurnBlockInfoProperty, CallableData,
+    CharType, FixedFunction, FunctionType, ListData, ListTypeData, OptionalData, PrincipalData,
     QualifiedContractIdentifier, ResponseData, SequenceData, StacksAddressExtensions,
     StandardPrincipalData, TraitIdentifier, TupleData, TupleTypeSignature, UTF8Data, BUFF_1,
     BUFF_32, BUFF_33,
@@ -539,21 +539,16 @@ pub fn call_function<'a, 'b, 'c>(
 
     // Convert the args into wasmtime values
     let mut wasm_args = vec![];
-    for arg in args {
+    for (arg, ty) in args.iter().zip(func_types.get_arg_types()) {
         let (arg_vec, new_offset, new_in_mem_offset) =
-            pass_argument_to_wasm(memory, &mut store, arg, offset, in_mem_offset)?;
+            pass_argument_to_wasm(memory, &mut store, ty, arg, offset, in_mem_offset)?;
         wasm_args.extend(arg_vec);
         offset = new_offset;
         in_mem_offset = new_in_mem_offset;
     }
 
     // Reserve stack space for the return value, if necessary.
-    let return_type = store
-        .data()
-        .contract_context()
-        .functions
-        .get(function_name)
-        .ok_or(CheckErrors::UndefinedFunction(function_name.to_string()))?
+    let return_type = func_types
         .get_return_type()
         .as_ref()
         .ok_or(Error::Wasm(WasmError::ExpectedReturnValue))?
@@ -1459,6 +1454,7 @@ fn write_to_wasm(
 fn pass_argument_to_wasm(
     memory: Memory,
     mut store: impl AsContextMut,
+    ty: &TypeSignature,
     value: &Value,
     offset: i32,
     in_mem_offset: i32,
@@ -1482,27 +1478,71 @@ fn pass_argument_to_wasm(
             in_mem_offset,
         )),
         Value::Optional(o) => {
-            let mut buffer = vec![Val::I32(if o.data.is_some() { 1 } else { 0 })];
-            let (inner, new_offset, new_in_mem_offset) = pass_argument_to_wasm(
+            let TypeSignature::OptionalType(inner_ty) = ty else {
+                return Err(Error::Wasm(WasmError::ValueTypeMismatch));
+            };
+
+            if let Some(inner_value) = o.data.as_ref() {
+                let mut buffer = vec![Val::I32(1)];
+                let (inner_buffer, new_offset, new_in_mem_offset) = pass_argument_to_wasm(
+                    memory,
+                    store,
+                    inner_ty,
+                    inner_value,
+                    offset,
+                    in_mem_offset,
+                )?;
+                buffer.extend(inner_buffer);
+                Ok((buffer, new_offset, new_in_mem_offset))
+            } else {
+                let buffer = clar2wasm_ty(ty)
+                    .into_iter()
+                    .map(|vt| match vt {
+                        ValType::I32 => Val::I32(0),
+                        ValType::I64 => Val::I64(0),
+                        _ => unreachable!("No other types used in Clarity-Wasm"),
+                    })
+                    .collect();
+                Ok((buffer, offset, in_mem_offset))
+            }
+        }
+        Value::Response(r) => {
+            let TypeSignature::ResponseType(inner_tys) = ty else {
+                return Err(Error::Wasm(WasmError::ValueTypeMismatch));
+            };
+            let mut buffer = vec![Val::I32(r.committed as i32)];
+            let (value_buffer, new_offset, new_in_mem_offset) = pass_argument_to_wasm(
                 memory,
                 store,
-                o.data
-                    .as_ref()
-                    .map_or(&Value::none(), |boxed_value| &boxed_value),
+                if r.committed {
+                    &inner_tys.0
+                } else {
+                    &inner_tys.1
+                },
+                &r.data,
                 offset,
                 in_mem_offset,
             )?;
-            buffer.extend(inner);
-            Ok((buffer, new_offset, new_in_mem_offset))
-        }
-        Value::Response(r) => {
-            let mut buffer = vec![Val::I32(if r.committed { 1 } else { 0 })];
-            let (inner, new_offset, new_in_mem_offset) = if r.committed {
-                pass_argument_to_wasm(memory, store, &r.data, offset, in_mem_offset)?
+            let empty_buffer = clar2wasm_ty(if r.committed {
+                &inner_tys.1
             } else {
-                pass_argument_to_wasm(memory, store, &r.data, offset, in_mem_offset)?
-            };
-            buffer.extend(inner);
+                &inner_tys.0
+            })
+            .into_iter()
+            .map(|vt| match vt {
+                ValType::I32 => Val::I32(0),
+                ValType::I64 => Val::I64(0),
+                _ => unreachable!("No other types used in Clarity-Wasm"),
+            });
+
+            if r.committed {
+                buffer.extend(value_buffer);
+                buffer.extend(empty_buffer);
+            } else {
+                buffer.extend(empty_buffer);
+                buffer.extend(value_buffer);
+            }
+
             Ok((buffer, new_offset, new_in_mem_offset))
         }
         Value::Sequence(SequenceData::String(CharType::ASCII(s))) => {
@@ -1519,8 +1559,20 @@ fn pass_argument_to_wasm(
             let adjusted_in_mem_offset = in_mem_offset + s.data.len() as i32;
             Ok((buffer, offset, adjusted_in_mem_offset))
         }
-        Value::Sequence(SequenceData::String(CharType::UTF8(_s))) => {
-            todo!("Value type not yet implemented: {:?}", value)
+        Value::Sequence(SequenceData::String(CharType::UTF8(s))) => {
+            // For a utf8 string, convert the chars to big-endian i32, convert this into a list of
+            // bytes, then pass the offset and length to the wasm function
+            let bytes: Vec<u8> = String::from_utf8(s.items().iter().flatten().copied().collect())
+                .map_err(|e| Error::Wasm(WasmError::WasmGeneratorError(e.to_string())))?
+                .chars()
+                .flat_map(|c| (c as u32).to_be_bytes())
+                .collect();
+            let buffer = vec![Val::I32(in_mem_offset), Val::I32(bytes.len() as i32)];
+            memory
+                .write(&mut store, in_mem_offset as usize, &bytes)
+                .map_err(|e| Error::Wasm(WasmError::UnableToWriteMemory(e.into())))?;
+            let adjusted_in_mem_offset = in_mem_offset + bytes.len() as i32;
+            Ok((buffer, offset, adjusted_in_mem_offset))
         }
         Value::Sequence(SequenceData::Buffer(b)) => {
             // For a buffer, write the bytes into the memory, then pass the
@@ -1537,14 +1589,18 @@ fn pass_argument_to_wasm(
             Ok((buffer, offset, adjusted_in_mem_offset))
         }
         Value::Sequence(SequenceData::List(l)) => {
+            let TypeSignature::SequenceType(SequenceSubtype::ListType(ltd)) = ty else {
+                return Err(Error::Wasm(WasmError::ValueTypeMismatch));
+            };
+
             let mut buffer = vec![Val::I32(offset)];
             let mut written = 0;
             let mut in_mem_written = 0;
             for item in &l.data {
                 let (len, in_mem_len) = write_to_wasm(
                     &mut store,
                     memory,
-                    l.type_signature.get_list_item_type(),
+                    ltd.get_list_item_type(),
                     offset + written,
                     in_mem_offset + in_mem_written,
                     item,
@@ -1556,9 +1612,61 @@ fn pass_argument_to_wasm(
             buffer.push(Val::I32(written));
             Ok((buffer, offset + written, in_mem_offset + in_mem_written))
         }
-        Value::Principal(_p) => todo!("Value type not yet implemented: {:?}", value),
-        Value::CallableContract(_c) => todo!("Value type not yet implemented: {:?}", value),
-        Value::Tuple(_t) => todo!("Value type not yet implemented: {:?}", value),
+        Value::Principal(PrincipalData::Standard(StandardPrincipalData(v, h))) => {
+            let bytes: Vec<u8> = std::iter::once(v).chain(h.iter()).copied().collect();
+            let buffer = vec![Val::I32(in_mem_offset), Val::I32(bytes.len() as i32)];
+            memory
+                .write(&mut store, in_mem_offset as usize, &bytes)
+                .map_err(|e| Error::Wasm(WasmError::UnableToWriteMemory(e.into())))?;
+            let adjusted_in_mem_offset = in_mem_offset + bytes.len() as i32;
+            Ok((buffer, offset, adjusted_in_mem_offset))
+        }
+        Value::Principal(PrincipalData::Contract(p))
+        | Value::CallableContract(CallableData {
+            contract_identifier: p,
+            ..
+        }) => {
+            // Callable types can just ignore the optional trait identifier, and
+            // is handled like a qualified contract
+            let QualifiedContractIdentifier {
+                issuer: StandardPrincipalData(v, h),
+                name,
+            } = p;
+            let bytes: Vec<u8> = std::iter::once(v)
+                .chain(h.iter())
+                .chain(std::iter::once(&name.len()))
+                .chain(name.as_bytes())
+                .copied()
+                .collect();
+            let buffer = vec![Val::I32(in_mem_offset), Val::I32(bytes.len() as i32)];
+            memory
+                .write(&mut store, in_mem_offset as usize, &bytes)
+                .map_err(|e| Error::Wasm(WasmError::UnableToWriteMemory(e.into())))?;
+            let adjusted_in_mem_offset = in_mem_offset + bytes.len() as i32;
+            Ok((buffer, offset, adjusted_in_mem_offset))
+        }
+        Value::Tuple(TupleData { data_map, .. }) => {
+            let TypeSignature::TupleType(tuple_ty) = ty else {
+                return Err(Error::Wasm(WasmError::ValueTypeMismatch));
+            };
+
+            let mut buffer = vec![];
+            let mut offset = offset;
+            let mut in_mem_offset = in_mem_offset;
+            for (name, ty) in tuple_ty.get_type_map() {
+                let b;
+                (b, offset, in_mem_offset) = pass_argument_to_wasm(
+                    memory,
+                    store.as_context_mut(),
+                    ty,
+                    &data_map[name],
+                    offset,
+                    in_mem_offset,
+                )?;
+                buffer.extend(b);
+            }
+            Ok((buffer, offset, in_mem_offset))
+        }
     }
 }