@thalalabs/surf 0.0.10 → 0.0.12

package/src/core/__tests__/option.test.ts

@@ -0,0 +1,144 @@
+/**
+ * These test cases depends on network, it call the real contract.
+ */
+
+import { AptosAccount } from 'aptos';
+import { createClient } from '../Client';
+import { createViewPayload } from '../createViewPayload';
+import { createEntryPayload } from '../createEntryPayload';
+
+describe('option type', () => {
+  const client = createClient({
+    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
+  });
+
+  const account = new AptosAccount(
+    undefined,
+    '0xac914efd2367c7aa42c95d100592c099e487d2270bf0e0761e5fe93ff4016593',
+  );
+
+  // TODO: correctly encode option type for view function
+  it('view function some value', async () => {
+    const payload = createViewPayload(OPTION_ABI, {
+      function: 'test_option_view',
+      arguments: [{ vec: ['50'] } as any],
+      type_arguments: [],
+    });
+    const result = await client.view(payload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        50n,
+      ]
+    `);
+  }, 60000);
+
+  it('view function none value', async () => {
+    const payload = createViewPayload(OPTION_ABI, {
+      function: 'test_option_view',
+      arguments: [{ vec: [] } as any],
+      type_arguments: [],
+    });
+    const result = await client.view(payload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        0n,
+      ]
+    `);
+  }, 60000);
+
+  it('entry function none value', async () => {
+    const payload = createEntryPayload(OPTION_ABI, {
+      function: 'test_option_entry',
+      arguments: [[]],
+      type_arguments: [],
+    });
+
+    const result = await client.simulateTransaction(payload, { account });
+
+    expect(result.hash).toBeDefined();
+    expect((result as any).payload).toMatchInlineSnapshot(`
+      {
+        "arguments": [
+          {
+            "vec": [],
+          },
+        ],
+        "function": "0xf1ab5cd814ef1480b8c36466310d9c21d7758b54f6121872d1fb43887a40e7d8::test_option::test_option_entry",
+        "type": "entry_function_payload",
+        "type_arguments": [],
+      }
+    `);
+  }, 60000);
+
+  it('entry function some value', async () => {
+    const payload = createEntryPayload(OPTION_ABI, {
+      function: 'test_option_entry',
+      arguments: [[50]],
+      type_arguments: [],
+    });
+
+    const result = await client.simulateTransaction(payload, { account });
+
+    expect(result.hash).toBeDefined();
+    expect((result as any).payload).toMatchInlineSnapshot(`
+      {
+        "arguments": [
+          {
+            "vec": [
+              "50",
+            ],
+          },
+        ],
+        "function": "0xf1ab5cd814ef1480b8c36466310d9c21d7758b54f6121872d1fb43887a40e7d8::test_option::test_option_entry",
+        "type": "entry_function_payload",
+        "type_arguments": [],
+      }
+    `);
+  }, 60000);
+
+  it('entry function incorrect type', async () => {
+    // no need to run, only for type check
+    () => {
+      createEntryPayload(OPTION_ABI, {
+        function: 'test_option_entry',
+        // @ts-expect-error should be a vector
+        arguments: [{}],
+        type_arguments: [],
+      });
+
+      createEntryPayload(OPTION_ABI, {
+        function: 'test_option_entry',
+        // @ts-expect-error should be a vector with length 0 or 1
+        arguments: [[1, 2]],
+        type_arguments: [],
+      });
+    }
+  }, 60000);
+});
+
+const OPTION_ABI = {
+  address: '0xf1ab5cd814ef1480b8c36466310d9c21d7758b54f6121872d1fb43887a40e7d8',
+  name: 'test_option',
+  friends: [],
+  exposed_functions: [
+    {
+      name: 'test_option_entry',
+      visibility: 'public',
+      is_entry: true,
+      is_view: false,
+      generic_type_params: [],
+      params: ['0x1::option::Option<u64>'],
+      return: [],
+    },
+    {
+      name: 'test_option_view',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['0x1::option::Option<u64>'],
+      return: ['u64'],
+    },
+  ],
+  structs: [],
+} as const;

package/src/core/createEntryPayload.ts

@@ -1,11 +1,15 @@
-import { BCS, TxnBuilderTypes, TypeTagParser } from "aptos";
-import { ensureBigInt, ensureBoolean, ensureNumber } from "../ensureTypes.js";
-import type { ABIRoot, EntryPayload } from "../types/index.js";
-import type { EntryFunctionName, EntryRequestPayload } from "../types/common.js";
+import { BCS, TxnBuilderTypes, TypeTagParser } from 'aptos';
+import { ensureBigInt, ensureBoolean, ensureNumber } from '../ensureTypes.js';
+import type {
+  ABIRoot,
+  EntryPayload,
+  EntryRequestPayload,
+} from '../types/index.js';
+import { EntryFunctionName } from '../types/extractor/functionExtractor.js';
 
 /**
  * Create a payload for calling a entry function.
- * 
+ *
  * @param abi The ABI JSON contains the entry function. For type inference and encoding/decoding purpose.
  * @param payload.function The function name.
  * @param payload.arguments The input arguments for function.
@@ -17,130 +21,167 @@ import type { EntryFunctionName, EntryRequestPayload } from "../types/common.js"
  *     arguments: ['0x1', 1],
  *     type_arguments: ['0x1::aptos_coin::AptosCoin'],
  * });
- * 
+ *
  * const { hash } = await client.submitTransaction(
- *     entryPayload, 
+ *     entryPayload,
  *     { account },
  * );
  */
 export function createEntryPayload<
-    T extends ABIRoot,
-    TFuncName extends EntryFunctionName<T>
->(
-    abi: T,
-    payload: EntryRequestPayload<T, TFuncName>
-): EntryPayload {
-    // TODO: remove unused variables
-    const fnAbi = abi.exposed_functions.filter(f => f.name === payload.function)[0]!;
-    const typeArguments: string[] = payload.type_arguments as any[];
-    const valArguments: any[] = payload.arguments as any[];
-    const abiArgs = fnAbi.params[0] === '&signer'
-        ? (fnAbi.params as string[]).slice(1)
-        : fnAbi.params as string[];
+  T extends ABIRoot,
+  TFuncName extends EntryFunctionName<T>,
+>(abi: T, payload: EntryRequestPayload<T, TFuncName>): EntryPayload {
+  // TODO: remove unused variables
+  const fnAbi = abi.exposed_functions.filter(
+    (f) => f.name === payload.function,
+  )[0]!;
+  const typeArguments: string[] = payload.type_arguments as any[];
+  const valArguments: any[] = payload.arguments as any[];
+  const abiArgs =
+    fnAbi.params[0] === '&signer'
+      ? (fnAbi.params as string[]).slice(1)
+      : (fnAbi.params as string[]);
 
-    // Validations
-    if (fnAbi === undefined) throw new Error(`Function ${payload.function} not found in ABI`);
-    if (abiArgs.length !== valArguments.length) throw new Error(`Function ${payload.function} expects ${fnAbi.params.length} arguments, but ${payload.arguments.length} were provided`);
-    if (fnAbi.generic_type_params.length !== typeArguments.length) throw new Error(`Function ${payload.function} expects ${fnAbi.generic_type_params.length} type arguments, but ${payload.type_arguments.length} were provided`);
+  // Validations
+  if (fnAbi === undefined)
+    throw new Error(`Function ${payload.function} not found in ABI`);
+  if (abiArgs.length !== valArguments.length)
+    throw new Error(
+      `Function ${payload.function} expects ${fnAbi.params.length} arguments, but ${payload.arguments.length} were provided`,
+    );
+  if (fnAbi.generic_type_params.length !== typeArguments.length)
+    throw new Error(
+      `Function ${payload.function} expects ${fnAbi.generic_type_params.length} type arguments, but ${payload.type_arguments.length} were provided`,
+    );
 
-    // TODO: make entryRequest lazy
-    return {
-        rawPayload: {
-            ...payload,
-            function: `${abi.address}::${abi.name}::${payload.function}`,
-        } as any,
-        entryRequest: TxnBuilderTypes.EntryFunction.natural(
-            `${abi.address}::${abi.name}`, // module id
-            payload.function, // function name
-            typeArguments // type arguments
-                .map((arg) => {
-                    // The StructTag.fromString not support nested struct tag before aptos@1.8.4.
-                    // So we use the TypeTagParser to parse the string literal into a TypeTagStruct
-                    // For better compatibility.
-                    // The next line of code is simpler, but not compatible with aptos below 1.8.3.
-                    // return new TxnBuilderTypes.TypeTagStruct(TxnBuilderTypes.StructTag.fromString(arg));
+  // TODO: make entryRequest lazy
+  return {
+    rawPayload: {
+      ...payload,
+      function: `${abi.address}::${abi.name}::${payload.function}`,
+    } as any,
+    entryRequest: TxnBuilderTypes.EntryFunction.natural(
+      `${abi.address}::${abi.name}`, // module id
+      payload.function, // function name
+      typeArguments // type arguments
+        .map((arg) => {
+          // The StructTag.fromString not support nested struct tag before aptos@1.8.4.
+          // So we use the TypeTagParser to parse the string literal into a TypeTagStruct
+          // For better compatibility.
+          // The next line of code is simpler, but not compatible with aptos below 1.8.3.
+          // return new TxnBuilderTypes.TypeTagStruct(TxnBuilderTypes.StructTag.fromString(arg));
 
-                    // Use the TypeTagParser to parse the string literal into a TypeTagStruct
-                    const typeTagStruct = new TypeTagParser(arg).parseTypeTag() as TxnBuilderTypes.TypeTagStruct;
+          // Use the TypeTagParser to parse the string literal into a TypeTagStruct
+          const typeTagStruct = new TypeTagParser(
+            arg,
+          ).parseTypeTag() as TxnBuilderTypes.TypeTagStruct;
 
-                    // Convert and return as a StructTag
-                    return new TxnBuilderTypes.TypeTagStruct(new TxnBuilderTypes.StructTag(
-                        typeTagStruct.value.address,
-                        typeTagStruct.value.module_name,
-                        typeTagStruct.value.name,
-                        typeTagStruct.value.type_args,
-                    ));
-                }),
-            valArguments.map( // arguments
-                (arg, i) => {
-                    const type = abiArgs[i]!;
-                    const serializer = new BCS.Serializer();
-                    argToBCS(type, arg, serializer);
-                    return serializer.getBytes();
-                }
-            )
-        )
-    };
+          // Convert and return as a StructTag
+          return new TxnBuilderTypes.TypeTagStruct(
+            new TxnBuilderTypes.StructTag(
+              typeTagStruct.value.address,
+              typeTagStruct.value.module_name,
+              typeTagStruct.value.name,
+              typeTagStruct.value.type_args,
+            ),
+          );
+        }),
+      valArguments.map(
+        // arguments
+        (arg, i) => {
+          const type = abiArgs[i]!;
+          const serializer = new BCS.Serializer();
+          argToBCS(type, arg, serializer);
+          return serializer.getBytes();
+        },
+      ),
+    ),
+  };
 }
 
-
 function argToBCS(type: string, arg: any, serializer: BCS.Serializer) {
+  const vectorRegex = /vector<([^]+)>/;
+  const vectorMatch = type.match(vectorRegex);
+  if (vectorMatch) {
+    // It's vector
+    const innerType = vectorMatch[1]!;
+    if (innerType === 'u8') {
+      if (arg instanceof Uint8Array) {
+        // TODO: add type support for Uint8Array
+        serializer.serializeBytes(arg);
+        return;
+      }
+
+      if (typeof arg === 'string') {
+        // TODO: add type support for string
+        serializer.serializeStr(arg);
+        return;
+      }
+    }
 
-    const regex = /vector<([^]+)>/;
-    const match = type.match(regex);
-    if (match) { // It's vector
-        const innerType = match[1]!;
-        if (innerType === 'u8') {
-            if (arg instanceof Uint8Array) { // TODO: add type support for Uint8Array
-                serializer.serializeBytes(arg);
-                return;
-            }
+    if (!Array.isArray(arg)) {
+      throw new Error('Invalid vector args.');
+    }
 
-            if (typeof arg === "string") { // TODO: add type support for string
-                serializer.serializeStr(arg);
-                return;
-            }
-        }
+    serializer.serializeU32AsUleb128(arg.length);
 
-        if (!Array.isArray(arg)) {
-            throw new Error("Invalid vector args.");
-        }
+    arg.forEach((arg) => argToBCS(innerType, arg, serializer));
+    return;
+  }
 
-        serializer.serializeU32AsUleb128(arg.length);
+  const objectRegex = /0x1::object::Object<([^]+)>/;
+  const objectMatch = type.match(objectRegex);
+  if (objectMatch) {
+    // It's 0x1::object::Object
+    TxnBuilderTypes.AccountAddress.fromHex(arg as string).serialize(serializer);
+    return;
+  }
 
-        arg.forEach((arg) => argToBCS(innerType, arg, serializer));
-        return;
+  const optionRegex = /0x1::option::Option<([^]+)>/;
+  const optionMatch = type.match(optionRegex);
+  if (optionMatch) { // It's 0x1::option::Option
+    const innerType = optionMatch[1]!;
+    serializer.serializeU32AsUleb128(arg.length);
+    if(!(arg instanceof Array) || arg.length > 1) {
+        throw new Error('Invalid input value for 0x1::option::Option.');
     }
+    arg.forEach((arg) => argToBCS(innerType, arg, serializer));
+    return;
+  }
 
-    switch (type) { // It's primitive
-        case 'bool':
-            serializer.serializeBool(ensureBoolean(arg));
-            break;
-        case 'address':
-            TxnBuilderTypes.AccountAddress.fromHex(arg as string).serialize(serializer);
-            break;
-        case 'u8':
-            serializer.serializeU8(ensureNumber(arg));
-            break;
-        case 'u16':
-            serializer.serializeU16(ensureNumber(arg));
-            break;
-        case 'u32':
-            serializer.serializeU32(ensureNumber(arg));
-            break;
-        case 'u64':
-            serializer.serializeU64(ensureBigInt(arg));
-            break;
-        case 'u128':
-            serializer.serializeU128(ensureBigInt(arg));
-            break;
-        case 'u256':
-            serializer.serializeU256(ensureBigInt(arg));
-            break;
-        case '0x1::string::String':
-            serializer.serializeStr(arg as string);
-            break;
-        default:
-            throw new Error(`type "${type}" not supported`);
-    }
+  switch (
+    type // It's primitive
+  ) {
+    case 'bool':
+      serializer.serializeBool(ensureBoolean(arg));
+      break;
+    case 'address':
+      TxnBuilderTypes.AccountAddress.fromHex(arg as string).serialize(
+        serializer,
+      );
+      break;
+    case 'u8':
+      serializer.serializeU8(ensureNumber(arg));
+      break;
+    case 'u16':
+      serializer.serializeU16(ensureNumber(arg));
+      break;
+    case 'u32':
+      serializer.serializeU32(ensureNumber(arg));
+      break;
+    case 'u64':
+      serializer.serializeU64(ensureBigInt(arg));
+      break;
+    case 'u128':
+      serializer.serializeU128(ensureBigInt(arg));
+      break;
+    case 'u256':
+      serializer.serializeU256(ensureBigInt(arg));
+      break;
+    case '0x1::string::String':
+      serializer.serializeStr(arg as string);
+      break;
+    default:
+      throw new Error(`type "${type}" not supported`);
+  }
 }