feat: vector input support

.github/workflows/ci.yml

@@ -18,7 +18,7 @@ env:
   RUSTFLAGS: "-D warnings"
   FUEL_CORE_VERSION: 0.10.1
   RUST_VERSION: 1.61.0
-  FORC_VERSION: 0.24.4
+  FORC_VERSION: 0.24.5
 
 jobs:
   setup-test-projects:

docs/src/SUMMARY.md

@@ -46,6 +46,7 @@
     - [Structs and enums](./types/custom_types.md)
     - [String](./types/string.md)
     - [Bits256](./types/bits256.md)
+    - [Vectors](./types/vectors.md)
 - [API](./getting-started/api.md)
 - [Debugging](./debugging/debugging.md)
   - [Debugging abigen errors](./debugging/abigen.md)
@@ -55,7 +56,7 @@
   - [Running scripts](./testing/scripts.md)
   - [Tweaking the blockchain](./testing/chains.md)
 - [Cookbook](./cookbook/cookbook.md)
-  - [Custom consesuns parameters](./cookbook/custom-chain.md)
+  - [Custom consensus parameters](./cookbook/custom-chain.md)
   - [Deposit and Withdraw](./cookbook/deposit-and-withdraw.md)
   - [Transfer all assets](./cookbook/transfer-all-assets.md)
 - [Command Line Interfaces](./cli/index.md)

docs/src/types/custom_types.md

@@ -42,7 +42,6 @@ For instance, your Sway contract could look like this:
 ```Rust
 contract;
 
-use std::assert::assert;
 use std::hash::sha256;
 
 struct SimpleGeneric<T> {

docs/src/types/vectors.md

@@ -0,0 +1,15 @@
+# Vectors
+
+## Passing in vectors
+
+You can pass a Rust `std::vec::Vec` into your contract method transparently. The following code calls a Sway function which accepts and then returns a `Vec<SomeStruct<u32>>`.
+
+```rust,ignore
+{{#include ../../../packages/fuels/tests/harness.rs:passing_in_vec}}
+```
+
+You can use a vector just like you would use any other type -- e.g. a `[Vec<u32>; 2]` or a `SomeStruct<Vec<Bits256>>` etc.
+
+## Returning vectors
+
+This is currently not supported. If you try returning a type that is or contains a vector you will get a compile time error.

packages/fuels-contract/src/contract.rs

@@ -12,7 +12,7 @@ use fuel_gql_client::{
 };
 
 use fuels_core::abi_decoder::ABIDecoder;
-use fuels_core::abi_encoder::ABIEncoder;
+use fuels_core::abi_encoder::{ABIEncoder, UnresolvedBytes};
 use fuels_core::parameters::StorageConfiguration;
 use fuels_core::tx::{Bytes32, ContractId};
 use fuels_core::{
@@ -131,18 +131,18 @@ impl Contract {
         signature: Selector,
         args: &[Token],
     ) -> Result<ContractCallHandler<D>, Error> {
-        let encoded_args = ABIEncoder::encode(args).unwrap();
         let encoded_selector = signature;
 
         let tx_parameters = TxParameters::default();
         let call_parameters = CallParameters::default();
 
         let compute_custom_input_offset = Contract::should_compute_custom_input_offset(args);
 
+        let unresolved_bytes = ABIEncoder::encode(args)?;
         let contract_call = ContractCall {
             contract_id,
             encoded_selector,
-            encoded_args,
+            encoded_args: unresolved_bytes,
             call_parameters,
             compute_custom_input_offset,
             variable_outputs: None,
@@ -175,6 +175,7 @@ impl Contract {
                         | Token::Tuple(_)
                         | Token::Array(_)
                         | Token::Byte(_)
+                        | Token::Vector(_)
                 )
             })
     }
@@ -357,7 +358,7 @@ impl Contract {
 /// Contains all data relevant to a single contract call
 pub struct ContractCall {
     pub contract_id: Bech32ContractId,
-    pub encoded_args: Vec<u8>,
+    pub encoded_args: UnresolvedBytes,
     pub encoded_selector: Selector,
     pub call_parameters: CallParameters,
     pub compute_custom_input_offset: bool,
@@ -378,7 +379,7 @@ impl ContractCall {
 
         let (encoded_value, index) = match param_type.get_return_location() {
             ReturnLocation::ReturnData => {
-                match receipts.iter().find(|&receipt| receipt.data().is_some()) {
+                match receipts.iter().find(|&receipt| matches!(receipt, Receipt::ReturnData { data, .. } if !data.is_empty())) {
                     Some(r) => {
                         let index = receipts.iter().position(|elt| elt == r).unwrap();
                         (r.data().unwrap().to_vec(), Some(index))
@@ -484,6 +485,7 @@ where
             Some(ref mut outputs) => outputs.extend(new_message_outputs),
             None => self.contract_call.message_outputs = Some(new_message_outputs),
         }
+
         self
     }
 

packages/fuels-contract/src/script.rs

@@ -191,17 +191,19 @@ impl Script {
             // one argument, we need to calculate the `call_data_offset`,
             // which points to where the data for the custom types start in the
             // transaction. If it doesn't take any custom inputs, this isn't necessary.
-            if call.compute_custom_input_offset {
+            let encoded_args_start_offset = if call.compute_custom_input_offset {
                 // Custom inputs are stored after the previously added parameters,
                 // including custom_input_offset
                 let custom_input_offset =
                     segment_offset + AssetId::LEN + 2 * WORD_SIZE + ContractId::LEN + 2 * WORD_SIZE;
-                let custom_input_offset = custom_input_offset as Word;
-
-                script_data.extend(&custom_input_offset.to_be_bytes());
-            }
+                script_data.extend(&(custom_input_offset as Word).to_be_bytes());
+                custom_input_offset
+            } else {
+                segment_offset
+            };
 
-            script_data.extend(call.encoded_args.clone());
+            let bytes = call.encoded_args.resolve(encoded_args_start_offset as u64);
+            script_data.extend(bytes);
 
             // the data segment that holds the parameters for the next call
             // begins at the original offset + the data we added so far
@@ -397,7 +399,9 @@ impl Script {
 mod test {
     use super::*;
     use fuel_gql_client::client::schema::coin::CoinStatus;
+    use fuels_core::abi_encoder::ABIEncoder;
     use fuels_core::parameters::CallParameters;
+    use fuels_core::Token;
     use fuels_types::bech32::Bech32ContractId;
     use fuels_types::param_types::ParamType;
     use rand::Rng;
@@ -423,8 +427,11 @@ mod test {
 
         let selectors = vec![[7u8; 8], [8u8; 8], [9u8; 8]];
 
-        // Call 2 has a multiple inputs, compute_custom_input_offset will be true
-        let args = vec![[10u8; 8].to_vec(), [11u8; 16].to_vec(), [12u8; 8].to_vec()];
+        // Call 2 has multiple inputs, compute_custom_input_offset will be true
+
+        let args = [Token::U8(1), Token::U16(2), Token::U8(3)]
+            .map(|token| ABIEncoder::encode(&[token]).unwrap())
+            .to_vec();
 
         let calls: Vec<ContractCall> = (0..NUM_CALLS)
             .map(|i| ContractCall {
@@ -477,11 +484,11 @@ mod test {
         // Calls 1 and 3 have their input arguments after the selector
         let call_1_arg_offset = param_offsets[0].call_data_offset + ContractId::LEN + SELECTOR_LEN;
         let call_1_arg = script_data[call_1_arg_offset..call_1_arg_offset + WORD_SIZE].to_vec();
-        assert_eq!(call_1_arg, args[0].to_vec());
+        assert_eq!(call_1_arg, args[0].resolve(0));
 
         let call_3_arg_offset = param_offsets[2].call_data_offset + ContractId::LEN + SELECTOR_LEN;
         let call_3_arg = script_data[call_3_arg_offset..call_3_arg_offset + WORD_SIZE].to_vec();
-        assert_eq!(call_3_arg, args[2]);
+        assert_eq!(call_3_arg, args[2].resolve(0));
 
         // Call 2 has custom inputs and custom_input_offset
         let call_2_arg_offset = param_offsets[1].call_data_offset + ContractId::LEN + SELECTOR_LEN;
@@ -495,8 +502,8 @@ mod test {
         let custom_input_offset =
             param_offsets[1].call_data_offset + ContractId::LEN + SELECTOR_LEN + WORD_SIZE;
         let custom_input =
-            script_data[custom_input_offset..custom_input_offset + 2 * WORD_SIZE].to_vec();
-        assert_eq!(custom_input, args[1]);
+            script_data[custom_input_offset..custom_input_offset + WORD_SIZE].to_vec();
+        assert_eq!(custom_input, args[1].resolve(0));
     }
 
     #[test]