feat!: support v1 encoding in program types

.changeset/light-bikes-cover.md

@@ -0,0 +1,7 @@
+---
+"@fuel-ts/abi-coder": minor
+"@fuel-ts/forc": minor
+"@fuel-ts/program": minor
+---
+
+feat!: support `v1` encoding in program types

packages/abi-coder/src/FunctionFragment.ts

@@ -11,13 +11,15 @@ import type { DecodedValue, InputValue } from './encoding/coders/AbstractCoder';
 import { ByteCoder } from './encoding/coders/v0/ByteCoder';
 import { TupleCoder } from './encoding/coders/v0/TupleCoder';
 import { VecCoder } from './encoding/coders/v0/VecCoder';
+import { StdStringCoder } from './encoding/coders/v1/StdStringCoder';
+import { TupleCoder as TupleCoderV1 } from './encoding/coders/v1/TupleCoder';
 import type {
   JsonAbi,
   JsonAbiArgument,
   JsonAbiFunction,
   JsonAbiFunctionAttribute,
 } from './types/JsonAbi';
-import { OPTION_CODER_TYPE } from './utils/constants';
+import { ENCODING_V1, OPTION_CODER_TYPE } from './utils/constants';
 import type { Uint8ArrayWithDynamicData } from './utils/utilities';
 import { isPointerType, unpackDynamicData, findOrThrow, isHeapType } from './utils/utilities';
 
@@ -27,6 +29,8 @@ export class FunctionFragment<
 > {
   readonly signature: string;
   readonly selector: string;
+  readonly selectorBytes: Uint8Array;
+  readonly encoding?: string;
   readonly name: string;
   readonly jsonFn: JsonAbiFunction;
   readonly attributes: readonly JsonAbiFunctionAttribute[];
@@ -44,6 +48,8 @@ export class FunctionFragment<
     this.name = name;
     this.signature = FunctionFragment.getSignature(this.jsonAbi, this.jsonFn);
     this.selector = FunctionFragment.getFunctionSelector(this.signature);
+    this.selectorBytes = new StdStringCoder().encode(name);
+    this.encoding = this.jsonAbi.encoding;
     this.isInputDataPointer = this.#isInputDataPointer();
     this.outputMetadata = {
       isHeapType: this.#isOutputDataHeap(),
@@ -113,12 +119,14 @@ export class FunctionFragment<
     const coders = nonEmptyInputs.map((t) =>
       AbiCoder.getCoder(this.jsonAbi, t, {
         isRightPadded: nonEmptyInputs.length > 1,
+        encoding: this.encoding,
       })
     );
 
-    const coder = new TupleCoder(coders);
-    const results: Uint8ArrayWithDynamicData = coder.encode(shallowCopyValues);
-
+    if (this.encoding === ENCODING_V1) {
+      return new TupleCoderV1(coders).encode(shallowCopyValues);
+    }
+    const results: Uint8ArrayWithDynamicData = new TupleCoder(coders).encode(shallowCopyValues);
     return unpackDynamicData(results, offset, results.byteLength);
   }
 
@@ -182,7 +190,7 @@ export class FunctionFragment<
 
     const result = nonEmptyInputs.reduce(
       (obj: { decoded: unknown[]; offset: number }, input) => {
-        const coder = AbiCoder.getCoder(this.jsonAbi, input);
+        const coder = AbiCoder.getCoder(this.jsonAbi, input, { encoding: this.encoding });
         const [decodedValue, decodedValueByteSize] = coder.decode(bytes, obj.offset);
 
         return {
@@ -206,7 +214,9 @@ export class FunctionFragment<
     }
 
     const bytes = arrayify(data);
-    const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output);
+    const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output, {
+      encoding: this.encoding,
+    });
 
     return coder.decode(bytes, 0) as [DecodedValue | undefined, number];
   }

packages/abi-coder/src/Interface.ts

@@ -104,6 +104,7 @@ export class Interface<TAbi extends JsonAbi = JsonAbi> {
 
     return AbiCoder.encode(this.jsonAbi, configurable.configurableType, value, {
       isRightPadded: true,
+      encoding: this.jsonAbi.encoding,
     });
   }
 

packages/abi-coder/src/encoding/coders/v0/ByteCoder.test.ts

@@ -38,15 +38,6 @@ describe('ByteCoder', () => {
     expect(actual).toStrictEqual(expected);
   });
 
-  it('should throw when value to encode is not array', async () => {
-    const coder = new ByteCoder();
-    const nonArrayInput = { ...[1] };
-    await expectToThrowFuelError(
-      () => coder.encode(nonArrayInput),
-      new FuelError(ErrorCode.ENCODE_ERROR, 'Expected array value.')
-    );
-  });
-
   it('should decode a byte', () => {
     const coder = new ByteCoder();
     const input = new Uint8Array([

packages/abi-coder/src/encoding/coders/v0/ByteCoder.ts

@@ -15,11 +15,7 @@ export class ByteCoder extends Coder<number[], Uint8Array> {
     super('struct', 'struct Bytes', BASE_VECTOR_OFFSET);
   }
 
-  encode(value: number[]): Uint8Array {
-    if (!Array.isArray(value)) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
-    }
-
+  encode(value: number[] | Uint8Array): Uint8Array {
     const parts: Uint8Array[] = [];
 
     // pointer (ptr)
@@ -42,8 +38,9 @@ export class ByteCoder extends Coder<number[], Uint8Array> {
     return concatWithDynamicData(parts);
   }
 
-  #getPaddedData(value: number[]): Uint8Array {
-    const data: Uint8Array[] = [Uint8Array.from(value)];
+  #getPaddedData(value: number[] | Uint8Array): Uint8Array {
+    const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+    const data: Uint8Array[] = [Uint8Array.from(bytes)];
 
     const paddingLength = (WORD_SIZE - (value.length % WORD_SIZE)) % WORD_SIZE;
     if (paddingLength) {

packages/abi-coder/src/encoding/coders/v0/OptionCoder.ts

@@ -23,8 +23,7 @@ export class OptionCoder<TCoders extends Record<string, Coder>> extends EnumCode
   }
 
   decode(data: Uint8Array, offset: number): [DecodedValueOf<TCoders>, number] {
-    // An empty option will be one less than the expected encoded length
-    if (data.length < this.encodedLength - 1) {
+    if (data.length < this.encodedLength) {
       throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid option data size.`);
     }
 

packages/abi-coder/src/encoding/coders/v1/ByteCoder.ts

@@ -11,13 +11,9 @@ export class ByteCoder extends Coder<number[], Uint8Array> {
     super('struct', 'struct Bytes', WORD_SIZE);
   }
 
-  encode(value: number[]): Uint8Array {
-    if (!Array.isArray(value)) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
-    }
-
-    const bytes = new Uint8Array(value);
-    const lengthBytes = new BigNumberCoder('u64').encode(value.length);
+  encode(value: number[] | Uint8Array): Uint8Array {
+    const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+    const lengthBytes = new BigNumberCoder('u64').encode(bytes.length);
 
     return new Uint8Array([...lengthBytes, ...bytes]);
   }

packages/abi-coder/src/encoding/coders/v1/OptionCoder.ts

@@ -0,0 +1,35 @@
+import type { Coder } from '../AbstractCoder';
+
+import type { InputValueOf, DecodedValueOf } from './EnumCoder';
+import { EnumCoder } from './EnumCoder';
+
+type SwayOption<T> = { None: [] } | { Some: T };
+export type Option<T> = T | undefined;
+
+export class OptionCoder<TCoders extends Record<string, Coder>> extends EnumCoder<TCoders> {
+  encode(value: InputValueOf<TCoders>): Uint8Array {
+    const result = super.encode(this.toSwayOption(value) as unknown as InputValueOf<TCoders>);
+    return result;
+  }
+
+  toSwayOption(input: InputValueOf<TCoders>): SwayOption<unknown> {
+    if (input !== undefined) {
+      return { Some: input };
+    }
+
+    return { None: [] };
+  }
+
+  decode(data: Uint8Array, offset: number): [DecodedValueOf<TCoders>, number] {
+    const [decoded, newOffset] = super.decode(data, offset);
+    return [this.toOption(decoded) as DecodedValueOf<TCoders>, newOffset];
+  }
+
+  toOption(output?: DecodedValueOf<TCoders>): Option<unknown> {
+    if (output && 'Some' in output) {
+      return output.Some;
+    }
+
+    return undefined;
+  }
+}

packages/abi-coder/src/encoding/coders/v1/StructCoder.ts

@@ -3,7 +3,8 @@ import { concatBytes } from '@fuel-ts/utils';
 
 import type { TypesOfCoder } from '../AbstractCoder';
 import { Coder } from '../AbstractCoder';
-import { OptionCoder } from '../v0/OptionCoder';
+
+import { OptionCoder } from './OptionCoder';
 
 type InputValueOf<TCoders extends Record<string, Coder>> = {
   [P in keyof TCoders]: TypesOfCoder<TCoders[P]>['Input'];

packages/abi-coder/src/encoding/strategies/getCoderV1.ts

@@ -32,13 +32,14 @@ import { ArrayCoder } from '../coders/v0/ArrayCoder';
 import { B256Coder } from '../coders/v0/B256Coder';
 import { B512Coder } from '../coders/v0/B512Coder';
 import { BigNumberCoder } from '../coders/v0/BigNumberCoder';
-import { OptionCoder } from '../coders/v0/OptionCoder';
 import { BooleanCoder } from '../coders/v1/BooleanCoder';
 import { ByteCoder } from '../coders/v1/ByteCoder';
 import { EnumCoder } from '../coders/v1/EnumCoder';
 import { NumberCoder } from '../coders/v1/NumberCoder';
+import { OptionCoder } from '../coders/v1/OptionCoder';
 import { RawSliceCoder } from '../coders/v1/RawSliceCoder';
 import { StdStringCoder } from '../coders/v1/StdStringCoder';
+import { StrSliceCoder } from '../coders/v1/StrSliceCoder';
 import { StringCoder } from '../coders/v1/StringCoder';
 import { StructCoder } from '../coders/v1/StructCoder';
 import { TupleCoder } from '../coders/v1/TupleCoder';
@@ -79,6 +80,8 @@ export const getCoder: GetCoderFn = (
       return new ByteCoder();
     case STD_STRING_CODER_TYPE:
       return new StdStringCoder();
+    case STR_SLICE_CODER_TYPE:
+      return new StrSliceCoder();
     default:
       break;
   }
@@ -149,13 +152,6 @@ export const getCoder: GetCoderFn = (
     return new TupleCoder(coders as Coder[]);
   }
 
-  if (resolvedAbiType.type === STR_SLICE_CODER_TYPE) {
-    throw new FuelError(
-      ErrorCode.INVALID_DATA,
-      'String slices can not be decoded from logs. Convert the slice to `str[N]` with `__to_str_array`'
-    );
-  }
-
   throw new FuelError(
     ErrorCode.CODER_NOT_FOUND,
     `Coder not found: ${JSON.stringify(resolvedAbiType)}.`

packages/abi-coder/src/index.ts

@@ -23,5 +23,7 @@ export {
   ASSET_ID_LEN,
   CONTRACT_ID_LEN,
   calculateVmTxMemory,
+  ENCODING_V0,
+  ENCODING_V1,
 } from './utils/constants';
 export { BigNumberCoder } from './encoding/coders/v0/BigNumberCoder';

packages/forc/VERSION_EXPERIMENTAL

@@ -1 +1 @@
-0.51.1
+0.52.0

packages/fuel-gauge/src/experimental-contract.test.ts

@@ -0,0 +1,89 @@
+import { readFileSync } from 'fs';
+import type { Contract } from 'fuels';
+import { bn } from 'fuels';
+import { join } from 'path';
+
+import { setup } from './utils';
+
+let contractInstance: Contract;
+
+const U8_MAX = 2 ** 8 - 1;
+const U16_MAX = 2 ** 16 - 1;
+const U32_MAX = 2 ** 32 - 1;
+const U64_MAX = bn(2).pow(64).sub(1);
+const U256_MAX = bn(2).pow(256).sub(1);
+const B512 =
+  '0x8e9dda6f7793745ac5aacf9e907cae30b2a01fdf0d23b7750a85c6a44fca0c29f0906f9d1f1e92e6a1fb3c3dcef3cc3b3cdbaae27e47b9d9a4c6a4fce4cf16b2';
+
+/**
+ * @group node
+ */
+describe('Experimental Contract', () => {
+  beforeAll(async () => {
+    const projectName = 'contract-echo';
+    const path = join(
+      __dirname,
+      `../test/fixtures/forc-projects-experimental/${projectName}/out/release/${projectName}`
+    );
+    const contractBytecode = readFileSync(`${path}.bin`);
+    const abi = JSON.parse(readFileSync(`${path}-abi.json`, 'utf8'));
+
+    contractInstance = await setup({ contractBytecode, abi });
+  });
+
+  it('echos mixed struct with all types', async () => {
+    const struct = {
+      a: U8_MAX,
+      b: U16_MAX,
+      c: U32_MAX,
+      d: U64_MAX,
+      e: U256_MAX,
+      f: '0xbebd3baab326f895289ecbd4210cf886ce41952316441ae4cac35f00f0e882a6',
+      g: B512,
+      native: 'Pending',
+      mixed: { Value: true },
+      grades: [1, 4, 6, 22],
+      fuel: 'fuel',
+      hello: 'Hello World',
+      opt: 42,
+      nada: undefined,
+      bytes: Uint8Array.from([40, 41, 42]),
+      tuple: [U8_MAX, U16_MAX, U32_MAX, 'fuel'],
+      vec_u8: [40, 41, 42],
+      str_slice: 'fuel',
+      deep: {
+        a: U8_MAX,
+        b: U16_MAX,
+        c: U32_MAX,
+        d: U64_MAX,
+        e: U256_MAX,
+        f: '0xbebd3baab326f895289ecbd4210cf886ce41952316441ae4cac35f00f0e882a6',
+        g: B512,
+        native: 'Pending',
+        mixed: { Value: true },
+        grades: [1, 4, 6, 22],
+        fuel: 'fuel',
+        hello: 'Hello World',
+        opt: 42,
+        nada: undefined,
+        bytes: Uint8Array.from([40, 41, 42]),
+        tuple: [U8_MAX, U16_MAX, U32_MAX, 'fuel'],
+        vec_u8: [40, 41, 42],
+        even_deeper: {
+          nested_vec: [1, 2, 3, 4, 5],
+          nested_str: 'fuel labs',
+          nested_raw: [88, 89, 90, 100],
+        },
+      },
+    };
+
+    const { value } = await contractInstance.functions.echo_struct(struct).call();
+    expect(value).toStrictEqual(struct);
+  });
+
+  it('extracts str slice from revert', async () => {
+    await expect(contractInstance.functions.test_revert().call()).rejects.toThrow(
+      /The script reverted with reason RequireFailed/
+    );
+  });
+});