feat: add support for StdString for Contracts, Scripts, and Predicates

.changeset/honest-plums-work.md

@@ -0,0 +1,6 @@
+---
+"@fuel-ts/abi-coder": minor
+"@fuel-ts/program": minor
+---
+
+Add StdString dynamic string type

packages/abi-coder/src/abi-coder.ts

@@ -11,6 +11,7 @@ import { EnumCoder } from './coders/enum';
 import { NumberCoder } from './coders/number';
 import { OptionCoder } from './coders/option';
 import { RawSliceCoder } from './coders/raw-slice';
+import { StdStringCoder } from './coders/stdString';
 import { StringCoder } from './coders/string';
 import { StructCoder } from './coders/struct';
 import { TupleCoder } from './coders/tuple';
@@ -25,6 +26,7 @@ import {
   OPTION_CODER_TYPE,
   VEC_CODER_TYPE,
   BYTES_CODER_TYPE,
+  STRING_CODER_TYPE,
 } from './constants';
 import type { JsonAbi, JsonAbiArgument } from './json-abi';
 import { ResolvedAbiType } from './resolved-abi-type';
@@ -69,6 +71,8 @@ export abstract class AbiCoder {
         return new B512Coder();
       case BYTES_CODER_TYPE:
         return new ByteCoder();
+      case STRING_CODER_TYPE:
+        return new StdStringCoder();
       default:
         break;
     }

packages/abi-coder/src/coders/stdString.test.ts

@@ -0,0 +1,92 @@
+import type { Uint8ArrayWithDynamicData } from '../utilities';
+
+import { StdStringCoder } from './stdString';
+
+describe('StdStringCoder', () => {
+  it('should encode an empty string', () => {
+    const coder = new StdStringCoder();
+    const expected: Uint8ArrayWithDynamicData = new Uint8Array([
+      0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]);
+    expected.dynamicData = {
+      0: new Uint8Array([]),
+    };
+
+    const actual = coder.encode('');
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should encode [hello world]', () => {
+    const coder = new StdStringCoder();
+    const expected: Uint8ArrayWithDynamicData = new Uint8Array([
+      0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 11,
+    ]);
+    expected.dynamicData = {
+      0: new Uint8Array([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 0, 0, 0, 0, 0]),
+    };
+
+    const actual = coder.encode('hello world');
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should encode [H3llo W0rld]', () => {
+    const coder = new StdStringCoder();
+    const expected: Uint8ArrayWithDynamicData = new Uint8Array([
+      0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 11,
+    ]);
+    expected.dynamicData = {
+      0: new Uint8Array([72, 51, 108, 108, 111, 32, 87, 48, 114, 108, 100, 0, 0, 0, 0, 0]),
+    };
+
+    const actual = coder.encode('H3llo W0rld');
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should encode [abcdefghijklmnopqrstuvwxyz1234567890]', () => {
+    const coder = new StdStringCoder();
+    const expected: Uint8ArrayWithDynamicData = new Uint8Array([
+      0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 36,
+    ]);
+    expected.dynamicData = {
+      0: new Uint8Array([
+        97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+        116, 117, 118, 119, 120, 121, 122, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 0, 0, 0, 0,
+      ]),
+    };
+
+    const actual = coder.encode('abcdefghijklmnopqrstuvwxyz1234567890');
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should decode a string', () => {
+    const coder = new StdStringCoder();
+    const input = new Uint8Array([
+      0, 0, 0, 0, 0, 0, 49, 120, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 11, 72, 101, 108,
+      108, 111, 32, 87, 111, 114, 108, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]);
+    const expected = 'Hello World';
+
+    const [actual, newOffset] = coder.decode(input, 0);
+
+    expect(actual).toEqual(expected);
+    expect(newOffset).toEqual(24);
+  });
+
+  it('should decode a string [with offset]', () => {
+    const coder = new StdStringCoder();
+    const input = new Uint8Array([
+      0, 0, 0, 0, 0, 0, 49, 120, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 11, 72, 101, 108,
+      108, 111, 32, 87, 111, 114, 108, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]);
+    const expected = 'Hello World';
+
+    const [actual, newOffset] = coder.decode(input, 16);
+
+    expect(actual).toEqual(expected);
+    expect(newOffset).toEqual(40);
+  });
+});

packages/abi-coder/src/coders/stdString.ts

@@ -0,0 +1,59 @@
+import { concat } from '@ethersproject/bytes';
+import { toUtf8Bytes, toUtf8String } from '@ethersproject/strings';
+import { bn } from '@fuel-ts/math';
+
+import { WORD_SIZE } from '../constants';
+import type { Uint8ArrayWithDynamicData } from '../utilities';
+import { BASE_VECTOR_OFFSET, concatWithDynamicData } from '../utilities';
+
+import { Coder } from './abstract-coder';
+import { U64Coder } from './u64';
+
+export class StdStringCoder extends Coder<string, string> {
+  static memorySize = 1;
+  constructor() {
+    super('struct', 'struct String', BASE_VECTOR_OFFSET);
+  }
+
+  encode(value: string): Uint8Array {
+    const parts: Uint8Array[] = [];
+
+    // pointer (ptr)
+    const pointer: Uint8ArrayWithDynamicData = new U64Coder().encode(BASE_VECTOR_OFFSET);
+
+    // pointer dynamicData, encode the string vector now and attach to its pointer
+    const data = this.#getPaddedData(value);
+    pointer.dynamicData = {
+      0: concatWithDynamicData([data]),
+    };
+
+    parts.push(pointer);
+
+    // capacity (cap)
+    parts.push(new U64Coder().encode(data.byteLength));
+
+    // length (len)
+    parts.push(new U64Coder().encode(value.length));
+
+    return concatWithDynamicData(parts);
+  }
+
+  #getPaddedData(value: string): Uint8Array {
+    const data: Uint8Array[] = [toUtf8Bytes(value)];
+
+    const paddingLength = (WORD_SIZE - (value.length % WORD_SIZE)) % WORD_SIZE;
+    if (paddingLength) {
+      data.push(new Uint8Array(paddingLength));
+    }
+
+    return concat(data);
+  }
+
+  decode(data: Uint8Array, offset: number): [string, number] {
+    const len = data.slice(16, 24);
+    const length = bn(new U64Coder().decode(len, 0)[0]).toNumber();
+    const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + length);
+    const value = toUtf8String(byteData);
+    return [value, offset + BASE_VECTOR_OFFSET];
+  }
+}

packages/abi-coder/src/constants.ts

@@ -1,6 +1,7 @@
 export const OPTION_CODER_TYPE = 'enum Option';
 export const VEC_CODER_TYPE = 'struct Vec';
 export const BYTES_CODER_TYPE = 'struct Bytes';
+export const STRING_CODER_TYPE = 'struct String';
 export const stringRegEx = /str\[(?<length>[0-9]+)\]/;
 export const arrayRegEx = /\[(?<item>[\w\s\\[\]]+);\s*(?<length>[0-9]+)\]/;
 export const structRegEx = /^struct (?<name>\w+)$/;

packages/abi-coder/src/utilities.ts

@@ -3,7 +3,7 @@ import { concat, arrayify } from '@ethersproject/bytes';
 import { ErrorCode, FuelError } from '@fuel-ts/errors';
 
 import { U64Coder } from './coders/u64';
-import { BYTES_CODER_TYPE, VEC_CODER_TYPE, WORD_SIZE } from './constants';
+import { BYTES_CODER_TYPE, VEC_CODER_TYPE, STRING_CODER_TYPE, WORD_SIZE } from './constants';
 
 export type DynamicData = {
   [pointerIndex: number]: Uint8ArrayWithDynamicData;
@@ -143,7 +143,8 @@ export const isPointerType = (type: string) => {
   }
 };
 
-export const isHeapType = (type: string) => type === VEC_CODER_TYPE || type === BYTES_CODER_TYPE;
+export const isHeapType = (type: string) =>
+  type === VEC_CODER_TYPE || type === BYTES_CODER_TYPE || type === STRING_CODER_TYPE;
 
 export function findOrThrow<T>(
   arr: readonly T[],

packages/abi-coder/test/interface.test.ts

@@ -307,7 +307,6 @@ describe('Abi interface', () => {
             const data = (decoded as BN[]).slice(0, 3);
             return Array.from(data);
           },
-          decodedTransfoarmer: (decoded: unknown | undefined) => Array.from(decoded as Uint8Array),
         },
         {
           fn: exhaustiveExamplesInterface.functions.raw_slice,
@@ -322,6 +321,15 @@ describe('Abi interface', () => {
             return data.map((v: BN) => v.toNumber());
           },
         },
+        {
+          fn: exhaustiveExamplesInterface.functions.dynamic_string,
+          title: '[struct String]',
+          value: 'H3llo W0rld',
+          encodedValue: new Uint8Array([
+            0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 11, 72, 51, 108,
+            108, 111, 32, 87, 48, 114, 108, 100, 0, 0, 0, 0, 0,
+          ]),
+        },
         {
           fn: exhaustiveExamplesInterface.functions.tuple_as_param,
           title: '[tuple] as param',

packages/abi-coder/test/sway-projects/exhaustive-examples/src/main.sw

@@ -1,6 +1,7 @@
 contract;
 use std::b512::B512;
 use std::bytes::Bytes;
+use std::string::String;
 
 enum EnumWithGeneric<T> {
     VariantOne: T,
@@ -135,6 +136,7 @@ abi MyContract {
     fn struct_with_implicitGenerics(arg: StructWithImplicitGenerics<b256, u8>) -> StructWithImplicitGenerics<b256, u8>;
     fn bytes(arg: Bytes) -> Bytes;
     fn raw_slice(arg: raw_slice) -> raw_slice;
+    fn dynamic_string(arg: String) -> String;
 
     fn tuple_as_param(x: (u8, StructA<StructB<u64>, str[3]>)) -> (u8, StructA<StructB<u64>, str[3]>);
     fn array_simple(x: [u8; 4]) -> [u8; 4];
@@ -253,6 +255,10 @@ impl MyContract for Contract {
     fn raw_slice(arg: raw_slice) -> raw_slice {
         arg 
     }
+
+    fn dynamic_string(arg: String) -> String { 
+        arg 
+    }
 
     fn two_u8_vectors(x: Vec<u8>, y: Vec<u8>) -> (Vec<u8>, Vec<u8>) {
         (x, y)

packages/fuel-gauge/fixtures/forc-projects/Forc.toml

@@ -22,6 +22,7 @@ members = [
   "predicate-main-args-vector",
   "predicate-multi-args",
   "predicate-raw-slice",
+  "predicate-std-lib-string",
   "predicate-struct",
   "predicate-triple-sig",
   "predicate-true",
@@ -35,11 +36,13 @@ members = [
   "script-main-return-struct",
   "script-main-two-args",
   "script-raw-slice",
+  "script-std-lib-string",
   "script-with-configurable",
   "script-with-array",
   "script-with-vector",
   "script-with-vector-advanced",
   "script-with-vector-mixed",
+  "std-lib-string",
   "storage-test-contract",
   "token_abi",
   "token_contract",

packages/fuel-gauge/fixtures/forc-projects/predicate-std-lib-string/Forc.toml

@@ -0,0 +1,7 @@
+[project]
+authors = ["FuelLabs"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "predicate-std-lib-string"
+
+[dependencies]

packages/fuel-gauge/fixtures/forc-projects/predicate-std-lib-string/src/main.sw

@@ -0,0 +1,30 @@
+predicate;
+
+use std::string::String;
+
+fn validate_string(arg: String) -> bool {
+    // to be replaced with a simpler assert_eq once
+    // https://github.com/FuelLabs/sway/issues/4868 is done
+    let bytes = arg.as_bytes();
+
+    let inner = String::from_ascii_str("Hello World");
+    let expected_bytes = inner.as_bytes();
+
+    if expected_bytes.len() != bytes.len() {
+        return false;
+    }
+
+    let mut i = 0;
+    while i < bytes.len() {
+        if expected_bytes.get(i).unwrap() != bytes.get(i).unwrap() {
+            return false;
+        }
+        i += 1;
+    }
+
+    true
+}
+
+fn main(_arg_0: u64, _arg_1: u64, arg_2: String) -> bool {
+    validate_string(arg_2)
+}

packages/fuel-gauge/fixtures/forc-projects/script-std-lib-string/Forc.toml

@@ -0,0 +1,7 @@
+[project]
+authors = ["FuelLabs"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "script-std-lib-string"
+
+[dependencies]

packages/fuel-gauge/fixtures/forc-projects/script-std-lib-string/src/main.sw

@@ -0,0 +1,24 @@
+script;
+
+use std::string::String;
+
+fn validate_string(arg: String) {
+    // to be replaced with a simpler assert_eq once
+    // https://github.com/FuelLabs/sway/issues/4868 is done
+    let bytes = arg.as_bytes();
+
+    let inner = String::from_ascii_str("Hello World");
+    let expected_bytes = inner.as_bytes();
+
+    assert_eq(expected_bytes.len(), bytes.len());
+
+    let mut i = 0;
+    while i < bytes.len() {
+        assert(expected_bytes.get(i).unwrap() == bytes.get(i).unwrap());
+        i += 1;
+    }
+}
+
+fn main(arg: String) {
+    validate_string(arg);
+}

packages/fuel-gauge/fixtures/forc-projects/std-lib-string/Forc.toml

@@ -0,0 +1,7 @@
+[project]
+authors = ["FuelLabs"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "std-lib-string"
+
+[dependencies]