@thalalabs/surf 0.0.1

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

@@ -0,0 +1,112 @@
+/**
+ * These test cases depends on network, it call the real contract.
+ */
+
+import { AptosAccount } from 'aptos';
+import { COIN_ABI } from '../../abi/coin';
+import { createClient } from '../Client';
+import { createEntryPayload } from '../createEntryPayload';
+
+describe('call entry functions', () => {
+  const client = createClient({
+    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
+  });
+
+  const account = new AptosAccount(
+    undefined,
+    '0xac914efd2367c7aa42c95d100592c099e487d2270bf0e0761e5fe93ff4016593',
+  );
+
+  // Act before assertions
+  beforeAll(async () => {});
+
+  // Teardown (cleanup) after assertions
+  afterAll(() => {});
+
+  it('basic', async () => {
+    const entryPayload = createEntryPayload(COIN_ABI, {
+      function: 'transfer',
+      arguments: ['0x1', 1],
+      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+    });
+
+    const result = await client.simulateTransaction(entryPayload, { account });
+
+    expect(result.hash).toBeDefined();
+    expect((result as any).payload).toMatchInlineSnapshot(`
+      {
+        "arguments": [
+          "0x1",
+          "1",
+        ],
+        "function": "0x1::coin::transfer",
+        "type": "entry_function_payload",
+        "type_arguments": [
+          "0x1::aptos_coin::AptosCoin",
+        ],
+      }
+    `);
+  }, 60000);
+
+  it('vector', async () => {
+    const entryPayload = createEntryPayload(TEST_ABI, {
+      function: 'test_run_function',
+      arguments: [[1, 2, 3, 10, 20, 30]],
+      type_arguments: [],
+    });
+
+    const result = await client.simulateTransaction(entryPayload, { account });
+
+    expect(result.hash).toBeDefined();
+    expect((result as any).payload).toMatchInlineSnapshot(`
+      {
+        "arguments": [
+          "0x0102030a141e",
+        ],
+        "function": "0x3d097bb505c9e5d8a96e367f371168240025877f6be8d4a88eacaafb709fe5c9::test::test_run_function",
+        "type": "entry_function_payload",
+        "type_arguments": [],
+      }
+    `);
+  }, 60000);
+});
+
+const TEST_ABI = {
+  address: '0x3d097bb505c9e5d8a96e367f371168240025877f6be8d4a88eacaafb709fe5c9',
+  name: 'test',
+  friends: [],
+  exposed_functions: [
+    {
+      name: 'test_run_function',
+      visibility: 'public',
+      is_entry: true,
+      is_view: false,
+      generic_type_params: [],
+      params: ['&signer', 'vector<u8>'],
+      return: [],
+    },
+    {
+      name: 'test_view_function',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['vector<u8>'],
+      return: ['u8'],
+    },
+  ],
+  structs: [
+    {
+      name: 'RunFunctionStruct',
+      is_native: false,
+      abilities: ['key'],
+      generic_type_params: [],
+      fields: [
+        {
+          name: 'sum',
+          type: 'u8',
+        },
+      ],
+    },
+  ],
+} as const;

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

@@ -0,0 +1,139 @@
+/**
+ * These test cases depends on network, it call the real contract.
+ */
+
+import { AptosAccount } from 'aptos';
+import { COIN_ABI } from '../../abi/coin';
+import { createClient } from '../Client';
+
+describe('useABI', () => {
+  const client = createClient({
+    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
+  });
+
+  const account = new AptosAccount(
+    undefined,
+    '0xac914efd2367c7aa42c95d100592c099e487d2270bf0e0761e5fe93ff4016593',
+  );
+
+  // Act before assertions
+  beforeAll(async () => {});
+
+  // Teardown (cleanup) after assertions
+  afterAll(() => {});
+
+  it('basic type checking', async () => {
+    // no need to run, type check only
+    () => {
+        // @ts-expect-error cannot call a function not exist
+        client.useABI(COIN_ABI).view.not_exist_func({
+            arguments: ['0x1'],
+            type_arguments: ['0x1::aptos_coin::AptosCoin'],
+        });
+  
+        // @ts-expect-error cannot call a entry function from view
+        client.useABI(COIN_ABI).view.transfer({
+            arguments: ['0x1'],
+            type_arguments: ['0x1::aptos_coin::AptosCoin'],
+        });
+
+        // @ts-expect-error cannot call a view function from entry
+        client.useABI(COIN_ABI).entry.balance({
+            arguments: ['0x1'],
+            type_arguments: ['0x1::aptos_coin::AptosCoin'],
+        });
+
+        client.useABI(TEST_ABI).view.address_as_input({
+            // @ts-expect-error require two args
+            arguments: ['0x1'],
+            type_arguments: [],
+        });
+
+        client.useABI(TEST_ABI).view.address_as_input({
+            // @ts-expect-error require address
+            arguments: ['0x1', 1],
+            type_arguments: [],
+        });
+
+        client.useABI(COIN_ABI).entry.transfer({
+            arguments: ['0x1', 1],
+            // @ts-expect-error require a type argument
+            type_arguments: [],
+            account
+        });
+            
+        // @ts-expect-error account is required for entry function
+        client.useABI(COIN_ABI).entry.transfer({
+            arguments: ['0x1', 1],
+            type_arguments: ['0x1::aptos_coin::AptosCoin'],
+        });
+      }
+  });
+
+  it('view', async () => {
+    const result = await client.useABI(COIN_ABI).view.name({
+      arguments: [],
+      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+    });
+    expect(result).toMatchInlineSnapshot(`
+      [
+        "Aptos Coin",
+      ]
+    `);
+
+    const result2 = await client.useABI(COIN_ABI).view.decimals({
+      arguments: [],
+      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+    });
+    expect(result2).toMatchInlineSnapshot(`
+      [
+        8,
+      ]
+    `);
+  }, 60000);
+
+  it('entry', async () => {
+    const result = await client.useABI(COIN_ABI).entry.transfer({
+      arguments: ['0x1', 1],
+      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      account,
+      isSimulation: true,
+    });
+    expect(result.hash).toBeDefined();
+    expect((result as any).payload).toMatchInlineSnapshot(`
+      {
+        "arguments": [
+          "0x1",
+          "1",
+        ],
+        "function": "0x1::coin::transfer",
+        "type": "entry_function_payload",
+        "type_arguments": [
+          "0x1::aptos_coin::AptosCoin",
+        ],
+      }
+    `);
+  }, 60000);
+});
+
+const TEST_ABI = {
+    "address": "0x123",
+    "name": "test",
+    "friends": [],
+    "exposed_functions": [
+      {
+        "name": "address_as_input",
+        "visibility": "public",
+        "is_entry": false,
+        "is_view": true,
+        "generic_type_params": [],
+        "params": [
+          "address",
+          "address",
+        ],
+        "return": []
+      },
+    ],
+    "structs": []
+  } as const;
+  

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

@@ -0,0 +1,145 @@
+/**
+ * These test cases depends on network, it call the real contract.
+ */
+
+import { COIN_ABI } from '../../abi/coin';
+import { createClient } from '../Client';
+import { createViewPayload } from '../createViewPayload';
+
+describe('call view functions', () => {
+    const client = createClient({
+        nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
+    });
+
+    const clientMain = createClient({
+        nodeUrl: 'https://fullnode.mainnet.aptoslabs.com/v1',
+    });
+
+    // Act before assertions
+    beforeAll(async () => { });
+
+    // Teardown (cleanup) after assertions
+    afterAll(() => { });
+
+    it('basic', async () => {
+        const viewPayload = createViewPayload(COIN_ABI, {
+            function: 'name',
+            arguments: [],
+            type_arguments: ['0x1::aptos_coin::AptosCoin'],
+        });
+        const result = await client.view(viewPayload);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        "Aptos Coin",
+      ]
+    `);
+
+        const viewPayload2 = createViewPayload(COIN_ABI, {
+            function: 'decimals',
+            arguments: [],
+            type_arguments: ['0x1::aptos_coin::AptosCoin'],
+        });
+        const result2 = await client.view(viewPayload2);
+        expect(result2).toMatchInlineSnapshot(`
+      [
+        8,
+      ]
+    `);
+    }, 60000);
+
+    it('vector', async () => {
+        const viewPayload = createViewPayload(TEST_ABI, {
+            function: 'test_view_function',
+            arguments: [[1, 2, 3, 10, 50]],
+            type_arguments: [],
+        });
+        const result = await client.view(viewPayload);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        66,
+      ]
+    `);
+    }, 60000);
+
+    it('struct', async () => {
+        const viewPayload = createViewPayload(TIERED_ORACLE_ABI, {
+            function: 'get_last_price',
+            arguments: [],
+            type_arguments: ['0x1::aptos_coin::AptosCoin'],
+        });
+
+        // The declaration in Move:
+        // struct FixedPoint64 has copy, drop, store { value: u128 }
+        const result = await clientMain.view(viewPayload);
+        expect(result.length).toBe(1);
+        expect((result[0] as any).v).toBeDefined();
+        expect(typeof (result[0] as any).v).toEqual("string");
+    }, 60000);
+});
+
+const TEST_ABI = {
+    address: '0x3d097bb505c9e5d8a96e367f371168240025877f6be8d4a88eacaafb709fe5c9',
+    name: 'test',
+    friends: [],
+    exposed_functions: [
+        {
+            name: 'test_run_function',
+            visibility: 'public',
+            is_entry: true,
+            is_view: false,
+            generic_type_params: [],
+            params: ['&signer', 'vector<u8>'],
+            return: [],
+        },
+        {
+            name: 'test_view_function',
+            visibility: 'public',
+            is_entry: false,
+            is_view: true,
+            generic_type_params: [],
+            params: ['vector<u8>'],
+            return: ['u8'],
+        },
+    ],
+    structs: [
+        {
+            name: 'RunFunctionStruct',
+            is_native: false,
+            abilities: ['key'],
+            generic_type_params: [],
+            fields: [
+                {
+                    name: 'sum',
+                    type: 'u8',
+                },
+            ],
+        },
+    ],
+} as const;
+
+const TIERED_ORACLE_ABI = {
+    "address": "0x92e95ed77b5ac815d3fbc2227e76db238339e9ca43ace45031ec2589bea5b8c",
+    "name": "tiered_oracle",
+    "friends": [
+        "0x92e95ed77b5ac815d3fbc2227e76db238339e9ca43ace45031ec2589bea5b8c::oracle"
+    ],
+    "exposed_functions": [
+        {
+            "name": "get_last_price",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": true,
+            "generic_type_params": [
+                {
+                    "constraints": []
+                }
+            ],
+            "params": [],
+            "return": [
+                "0x4dcae85fc5559071906cd5c76b7420fcbb4b0a92f00ab40ffc394aadbbff5ee9::fixed_point64::FixedPoint64"
+            ]
+        },
+
+    ],
+    "structs": []
+} as const;

package/src/core/createEntryPayload.ts

@@ -0,0 +1,128 @@
+import { BCS, TxnBuilderTypes, TypeTagParser } from "aptos";
+import { ensureBigInt, ensureBoolean, ensureNumber } from "../ensureTypes";
+import { ABIRoot, EntryPayload } from "../types";
+import { EntryFunctionName, EntryRequestPayload } from "../types/common";
+
+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[];
+
+    // 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));
+
+                    // 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();
+                }
+            )
+        )
+    };
+}
+
+
+function argToBCS(type: string, arg: any, serializer: BCS.Serializer) {
+
+    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 (typeof arg === "string") { // TODO: add type support for string
+                serializer.serializeStr(arg);
+                return;
+            }
+        }
+
+        if (!Array.isArray(arg)) {
+            throw new Error("Invalid vector args.");
+        }
+
+        serializer.serializeU32AsUleb128(arg.length);
+
+        arg.forEach((arg) => argToBCS(innerType, arg, serializer));
+        return;
+    }
+
+    // TODO: it's struct
+
+    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`);
+    }
+}

package/src/core/createViewPayload.ts

@@ -0,0 +1,100 @@
+import { HexString } from "aptos";
+import { ABIRoot, ViewPayload } from "../types";
+import { ExtractReturnType, ViewFunctionName, ViewRequestPayload } from "../types/common";
+import { ensureNumber } from "../ensureTypes";
+
+// TODO: support vector<u8> input with Uint8Array
+// TODO: support vector<u8> input with string
+export function createViewPayload<
+    T extends ABIRoot,
+    TFuncName extends ViewFunctionName<T>
+>(
+    abi: T,
+    payload: ViewRequestPayload<T, TFuncName>
+):
+    ViewPayload<ExtractReturnType<T, TFuncName>> {
+    const fnAbi = abi.exposed_functions.filter(f => f.name === payload.function)[0];
+    const type_arguments: string[] = payload.type_arguments as any[];
+    const val_arguments: any[] = payload.arguments as any[];
+
+    // Validations
+    if (fnAbi === undefined) throw new Error(`Function ${payload.function} not found in ABI`);
+    if (fnAbi.params.length !== val_arguments.length) throw new Error(`Function ${payload.function} expects ${fnAbi.params.length} arguments, but ${payload.arguments.length} were provided`);
+    if (fnAbi.generic_type_params.length !== type_arguments.length) throw new Error(`Function ${payload.function} expects ${fnAbi.generic_type_params.length} type arguments, but ${payload.type_arguments.length} were provided`);
+
+    // TODO: do serialization here
+    const args = fnAbi.params.map((type, i) => {
+        if (['u8', 'u16', 'u32'].includes(type)) {
+            return ensureNumber(payload.arguments[i] as number);
+        }
+        else if (['u64', 'u128', 'u256'].includes(type)) {
+            return payload.arguments[i].toString();
+        }
+        else if (type.includes("vector")) {
+            return encodeVector(type, payload.arguments[i] as any[]);
+        }
+        else {
+            return payload.arguments[i];
+        }
+    });
+
+    // used to decode the return value in response
+    const decoders = fnAbi.return.map((type) => {
+        if (['u64', 'u128', 'u256'].includes(type)) {
+            return decodeBigint;
+        }
+        else {
+            return null;
+        }
+    });
+
+    return {
+        viewRequest: {
+            function: `${abi.address}::${abi.name}::${payload.function}`,
+            arguments: args,
+            type_arguments: payload.type_arguments as string[],
+        },
+        decoders,
+    };
+}
+
+function decodeBigint(value: string): bigint {
+    return BigInt(value);
+}
+
+function encodeVector(type: string, value: any[]) {
+    const regex = /vector<([^]+)>/;
+    const match = type.match(regex);
+    if (!match) {
+        // Should never happen
+        throw new Error(`Unsupported type: ${type}`);
+    }
+
+    if (match[1] === "u8") {
+        return (
+            HexString.fromUint8Array(
+                new Uint8Array(
+                    value.map((v: number) => {
+                        const result = ensureNumber(v);
+                        if (result < 0 || result > 255)
+                            throw new Error(`Invalid u8 value: ${result}`);
+                        return result;
+                    }),
+                ),
+            ) as any
+        ).hexString;
+    } else if (["u16", "u32"].includes(match[1])) {
+        // TODO: Figure out how to encode
+        return value;
+    } else if (["u64", "u128", "u256"].includes(match[1])) {
+        // TODO: Figure out how to encode
+        return value.map((v: bigint) => v.toString());
+    } else if (match[1] === "bool") {
+        // TODO: Figure out how to encode
+        return value;
+    } else {
+        // 1. Address type no need to encode
+        // 2. TODO: Figure out how to encode Struct type
+        return value;
+    }
+}

package/src/core/index.ts

@@ -0,0 +1,4 @@
+export { WalletClient as MoveTsWalletClient } from "./WalletClient";
+export { Client as MoveTsClient, createClient } from "./Client";
+export { createViewPayload } from "./createViewPayload";
+export { createEntryPayload } from "./createEntryPayload";

package/src/ensureTypes.ts

@@ -0,0 +1,42 @@
+function assertType(val: any, types: string[] | string, message?: string) {
+    if (!types?.includes(typeof val)) {
+        throw new Error(
+            message || `Invalid arg: ${val} type should be ${types instanceof Array ? types.join(" or ") : types}`,
+        );
+    }
+}
+
+export function ensureBoolean(val: boolean | string): boolean {
+    assertType(val, ["boolean", "string"]);
+    if (typeof val === "boolean") {
+        return val;
+    }
+
+    if (val === "true") {
+        return true;
+    }
+    if (val === "false") {
+        return false;
+    }
+
+    throw new Error("Invalid boolean string.");
+}
+
+export function ensureNumber(val: number | string): number {
+    assertType(val, ["number", "string"]);
+    if (typeof val === "number") {
+        return val;
+    }
+
+    const res = Number.parseInt(val, 10);
+    if (Number.isNaN(res)) {
+        throw new Error("Invalid number string.");
+    }
+
+    return res;
+}
+
+export function ensureBigInt(val: number | bigint | string): bigint {
+    assertType(val, ["number", "bigint", "string"]);
+    return BigInt(val);
+}

package/src/hooks/index.ts

@@ -0,0 +1,2 @@
+export { submitTransactionOptions, useSubmitTransaction } from "./useSubmitTransaction";
+export { useWalletClient } from "./useWalletClient";