feat!: improve vector output support for contracts

.changeset/cyan-knives-attack.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/abi-coder": minor
+---
+
+removed byte coder

.changeset/sweet-sheep-double.md

@@ -0,0 +1,6 @@
+---
+"@fuel-ts/abi-coder": minor
+"@fuel-ts/program": minor
+---
+
+Added vector output

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

@@ -7,7 +7,6 @@ import { ArrayCoder } from './coders/array';
 import { B256Coder } from './coders/b256';
 import { B512Coder } from './coders/b512';
 import { BooleanCoder } from './coders/boolean';
-import { ByteCoder } from './coders/byte';
 import { EnumCoder } from './coders/enum';
 import { NumberCoder } from './coders/number';
 import { OptionCoder } from './coders/option';
@@ -61,8 +60,6 @@ export abstract class AbiCoder {
         return new U64Coder();
       case 'bool':
         return new BooleanCoder();
-      case 'byte':
-        return new ByteCoder();
       case 'b256':
         return new B256Coder();
       case 'struct B512':
@@ -78,12 +75,6 @@ export abstract class AbiCoder {
       return new StringCoder(length);
     }
 
-    if (['raw untyped slice'].includes(resolvedAbiType.type)) {
-      const length = 0;
-      const itemCoder = new U64Coder();
-      return new ArrayCoder(itemCoder, length);
-    }
-
     // ABI types underneath MUST have components by definition
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const components = resolvedAbiType.components!;

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

@@ -1,6 +1,7 @@
 import type { Uint8ArrayWithDynamicData } from '../utilities';
 
 import { BooleanCoder } from './boolean';
+import { NumberCoder } from './number';
 import { VecCoder } from './vec';
 
 describe('VecCoder', () => {
@@ -26,10 +27,17 @@ describe('VecCoder', () => {
     }).toThrow('expected array value');
   });
 
-  it('should throw an error when decoding', () => {
-    const coder = new VecCoder(new BooleanCoder());
-    const invalidInput = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]);
+  it('should decode a u8 Vec', () => {
+    const coder = new VecCoder(new NumberCoder('u8'));
+    const input = new Uint8Array([
+      0, 0, 0, 0, 0, 0, 41, 16, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0,
+      8, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7,
+    ]);
+    const expected = [8, 6, 7];
 
-    expect(() => coder.decode(invalidInput, 0)).toThrow('unexpected Vec decode');
+    const [actual, newOffset] = coder.decode(input, 0);
+
+    expect(actual).toEqual(expected);
+    expect(newOffset).toEqual(24);
   });
 });

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

@@ -1,5 +1,7 @@
+import { bn } from '@fuel-ts/math';
+
 import type { Uint8ArrayWithDynamicData } from '../utilities';
-import { concatWithDynamicData, BASE_VECTOR_OFFSET } from '../utilities';
+import { concatWithDynamicData, BASE_VECTOR_OFFSET, chunkByLength } from '../utilities';
 
 import type { TypesOfCoder } from './abstract-coder';
 import { Coder } from './abstract-coder';
@@ -44,7 +46,18 @@ export class VecCoder<TCoder extends Coder> extends Coder<
     return concatWithDynamicData(parts);
   }
 
-  decode(_data: Uint8Array, _offset: number): [DecodedValueOf<TCoder>, number] {
-    this.throwError('unexpected Vec decode', 'not implemented');
+  decode(data: Uint8Array, offset: number): [DecodedValueOf<TCoder>, number] {
+    const len = data.slice(16, 24);
+    const length = bn(new U64Coder().decode(len, 0)[0]).toNumber();
+    const vectorRawData = data.slice(
+      BASE_VECTOR_OFFSET,
+      BASE_VECTOR_OFFSET + length * this.coder.encodedLength
+    );
+    return [
+      chunkByLength(vectorRawData, this.coder.encodedLength).map(
+        (chunk) => this.coder.decode(chunk, 0)[0]
+      ),
+      offset + BASE_VECTOR_OFFSET,
+    ];
   }
 }

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

@@ -11,6 +11,7 @@ import type { DecodedValue, InputValue } from './coders/abstract-coder';
 import type { ArrayCoder } from './coders/array';
 import { TupleCoder } from './coders/tuple';
 import type { U64Coder } from './coders/u64';
+import { VecCoder } from './coders/vec';
 import { OPTION_CODER_TYPE } from './constants';
 import type {
   JsonAbi,
@@ -20,7 +21,7 @@ import type {
 } from './json-abi';
 import { ResolvedAbiType } from './resolved-abi-type';
 import type { Uint8ArrayWithDynamicData } from './utilities';
-import { isPointerType, unpackDynamicData, findOrThrow } from './utilities';
+import { isPointerType, unpackDynamicData, findOrThrow, isHeapType } from './utilities';
 
 const logger = new Logger(versions.FUELS);
 
@@ -33,6 +34,12 @@ export class FunctionFragment<
   readonly name: string;
   readonly jsonFn: JsonAbiFunction;
   readonly attributes: readonly JsonAbiFunctionAttribute[];
+  readonly isInputDataPointer: boolean;
+  readonly outputMetadata: {
+    isHeapType: boolean;
+    encodedLength: number;
+  };
+
   private readonly jsonAbi: JsonAbi;
 
   constructor(jsonAbi: JsonAbi, name: FnName) {
@@ -41,6 +48,11 @@ export class FunctionFragment<
     this.name = name;
     this.signature = FunctionFragment.getSignature(this.jsonAbi, this.jsonFn);
     this.selector = FunctionFragment.getFunctionSelector(this.signature);
+    this.isInputDataPointer = this.#isInputDataPointer();
+    this.outputMetadata = {
+      isHeapType: this.#isOutputDataHeap(),
+      encodedLength: this.#getOutputEncodedLength(),
+    };
 
     this.attributes = this.jsonFn.attributes ?? [];
   }
@@ -58,14 +70,33 @@ export class FunctionFragment<
     return bn(hashedFunctionSignature.slice(0, 10)).toHex(8);
   }
 
-  isInputDataPointer(): boolean {
+  #isInputDataPointer(): boolean {
     const inputTypes = this.jsonFn.inputs.map((i) =>
       this.jsonAbi.types.find((t) => t.typeId === i.type)
     );
 
     return this.jsonFn.inputs.length > 1 || isPointerType(inputTypes[0]?.type || '');
   }
 
+  #isOutputDataHeap(): boolean {
+    const outputType = findOrThrow(this.jsonAbi.types, (t) => t.typeId === this.jsonFn.output.type);
+
+    return isHeapType(outputType?.type || '');
+  }
+
+  #getOutputEncodedLength(): number {
+    try {
+      const heapCoder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output);
+      if (heapCoder instanceof VecCoder) {
+        return heapCoder.coder.encodedLength;
+      }
+
+      return heapCoder.encodedLength;
+    } catch (e) {
+      return 0;
+    }
+  }
+
   encodeArguments(values: InputValue[], offset = 0): Uint8Array {
     FunctionFragment.verifyArgsAndInputsAlign(values, this.jsonFn.inputs, this.jsonAbi);
 
@@ -134,14 +165,8 @@ export class FunctionFragment<
     }
 
     const result = nonEmptyInputs.reduce(
-      (obj: { decoded: unknown[]; offset: number }, input, currentIndex) => {
+      (obj: { decoded: unknown[]; offset: number }, input) => {
         const coder = AbiCoder.getCoder(this.jsonAbi, input);
-        if (currentIndex === 0) {
-          const inputAbiType = findOrThrow(this.jsonAbi.types, (t) => t.typeId === input.type);
-          if (inputAbiType.type === 'raw untyped slice') {
-            (coder as ArrayCoder<U64Coder>).length = bytes.length / 8;
-          }
-        }
         const [decodedValue, decodedValueByteSize] = coder.decode(bytes, obj.offset);
 
         return {

packages/abi-coder/src/index.ts

@@ -3,7 +3,6 @@ export { ArrayCoder } from './coders/array';
 export { B256Coder } from './coders/b256';
 export { B512Coder } from './coders/b512';
 export { BooleanCoder } from './coders/boolean';
-export { ByteCoder } from './coders/byte';
 export { EnumCoder } from './coders/enum';
 export { NumberCoder } from './coders/number';
 export { StringCoder } from './coders/string';

packages/abi-coder/src/utilities.ts

@@ -2,7 +2,7 @@ import type { BytesLike } from '@ethersproject/bytes';
 import { concat, arrayify } from '@ethersproject/bytes';
 
 import { U64Coder } from './coders/u64';
-import { WORD_SIZE } from './constants';
+import { VEC_CODER_TYPE, WORD_SIZE } from './constants';
 
 export type DynamicData = {
   [pointerIndex: number]: Uint8ArrayWithDynamicData;
@@ -87,7 +87,7 @@ export function unpackDynamicData(
   return updatedResults;
 }
 
-/** useful for debugging
+/**
  * Turns:
   Uint8Array(24) [
     0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 24
@@ -107,14 +107,14 @@ export function unpackDynamicData(
   ]
  * 
  */
-export const chunkByWord = (data: Uint8Array): Uint8Array[] => {
+export const chunkByLength = (data: Uint8Array, length = WORD_SIZE): Uint8Array[] => {
   const chunks = [];
   let offset = 0;
-  let chunk = data.slice(offset, offset + WORD_SIZE);
+  let chunk = data.slice(offset, offset + length);
   while (chunk.length) {
     chunks.push(chunk);
-    offset += WORD_SIZE;
-    chunk = data.slice(offset, offset + WORD_SIZE);
+    offset += length;
+    chunk = data.slice(offset, offset + length);
   }
 
   return chunks;
@@ -139,6 +139,8 @@ export const isPointerType = (type: string) => {
   }
 };
 
+export const isHeapType = (type: string) => type === VEC_CODER_TYPE;
+
 export function findOrThrow<T>(
   arr: readonly T[],
   predicate: (val: T) => boolean,