@thalalabs/surf 0.0.1

package/src/core/WalletClient.ts

@@ -0,0 +1,64 @@
+import { useWallet } from "@aptos-labs/wallet-adapter-react";
+import { AptosClient, Types } from "aptos";
+import { createEntryPayload } from "./createEntryPayload";
+import { ABIRoot, ABIWalletClient, EntryOptions, EntryPayload } from "../types";
+
+type Wallet = ReturnType<typeof useWallet>;
+
+export class WalletClient {
+    private wallet: Wallet;
+    private client: AptosClient;
+
+    constructor({ wallet, nodeUrl }: {
+        wallet: Wallet,
+        nodeUrl: string
+    }) {
+        this.wallet = wallet;
+        this.client = new AptosClient(nodeUrl);
+    }
+
+    public async submitTransaction(
+        payload: EntryPayload,
+        _: EntryOptions | undefined = undefined
+    ): Promise<{ hash: string }> { // TODO: make { hash: string } a individual type.
+        const request = payload.rawPayload;
+
+        // TODO: use the BCS API instead
+        const { hash } = await this.wallet.signAndSubmitTransaction({
+            type: "entry_function_payload",
+            ...request,
+            arguments: request.arguments.map((arg: any) => {
+                if (Array.isArray(arg)) {
+                    // TODO: support nested array, or use the BCS API instead
+                    return arg.map((item: any) => item.toString());
+                } else if (typeof arg === "object") {
+                    throw new Error(`a value of struct type: ${arg} is not supported`);
+                } else {
+                    return arg.toString();
+                }
+            }),
+        });
+
+        const result = (await this.client.waitForTransactionWithResult(hash, {
+            checkSuccess: true,
+        })) as Types.Transaction_UserTransaction;
+
+        return result;
+    }
+
+    public useABI<T extends ABIRoot>(abi: T) {
+        return new Proxy({} as ABIWalletClient<T>, {
+            get: (_, prop) => {
+                const functionName = prop.toString();
+                return (...args) => {
+                    const payload = createEntryPayload(abi, {
+                        function: functionName,
+                        type_arguments: args[0].type_arguments,
+                        arguments: args[0].arguments,
+                    });
+                    return this.submitTransaction(payload);
+                };
+            }
+        });
+    }
+}

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

@@ -0,0 +1,262 @@
+import { COIN_ABI } from "../../abi/coin";
+import { createEntryPayload } from "../createEntryPayload";
+
+// TODO: add struct, vector of vector, vector
+describe('createEntryPayload', () => {
+    // Act before assertions
+    beforeAll(async () => { });
+
+    // Teardown (cleanup) after assertions
+    afterAll(() => { });
+
+    it('basic type checking', async () => {
+        // no need to run, type check only.
+        () => {
+            createEntryPayload(COIN_ABI, {
+                // @ts-expect-error abc is not a function
+                function: 'abc',
+                arguments: ['0x1', 1],
+                type_arguments: ['0x1::aptos_coin::AptosCoin'],
+            });
+
+            createEntryPayload(COIN_ABI, {
+                // @ts-expect-error balance is not a view function
+                function: 'balance',
+                arguments: ['0x1', 1],
+                type_arguments: ['0x1::aptos_coin::AptosCoin'],
+            });
+
+            createEntryPayload(COIN_ABI, {
+                function: 'transfer',
+                // @ts-expect-error require a address type
+                arguments: [1, 1],
+                type_arguments: ['0x1::aptos_coin::AptosCoin'],
+            });
+
+            createEntryPayload(COIN_ABI, {
+                function: 'transfer',
+                // @ts-expect-error require 2 args
+                arguments: ['0x1', 1, 1],
+                type_arguments: ['0x1::aptos_coin::AptosCoin'],
+            });
+
+            createEntryPayload(COIN_ABI, {
+                function: 'transfer',
+                arguments: ['0x1', 1],
+                // @ts-expect-error require a type_argument
+                type_arguments: [],
+            });
+
+            createEntryPayload(COIN_ABI, {
+                function: 'transfer',
+                arguments: ['0x1', 1],
+                type_arguments: ['0x1::aptos_coin::AptosCoin'],
+            });
+        }
+    });
+
+    it('number', async () => {
+        createEntryPayload(TEST_ABI, {
+            function: 'number_as_input',
+            arguments: [1, 2, 3, BigInt(4), BigInt(5), BigInt(6)],
+            type_arguments: [],
+        });
+
+        // no need to run, type check only.
+        () => {
+            createEntryPayload(TEST_ABI, {
+                function: 'number_as_input',
+                arguments: [
+                    // @ts-expect-error the input type for u8 should be number, not bigint
+                    BigInt(1),
+                    // @ts-expect-error the input type for u16 should be number, not bigint
+                    BigInt(2),
+                    // @ts-expect-error the input type for u32 should be number, not bigint
+                    BigInt(2),
+                    BigInt(4), BigInt(5), BigInt(6)],
+                type_arguments: [],
+            });
+        }
+    });
+
+    it('bool', async () => {
+        createEntryPayload(TEST_ABI, {
+            function: 'bool_as_input',
+            arguments: [true, false],
+            type_arguments: [],
+        });
+
+        // no need to run, type check only.
+        () => {
+            createEntryPayload(TEST_ABI, {
+                function: 'bool_as_input',
+                arguments: [
+                    // @ts-expect-error invalid bool
+                    1,
+                    // @ts-expect-error invalid bool
+                    'true',
+                ],
+                type_arguments: [],
+            });
+
+        }
+    });
+
+    it('address', async () => {
+        createEntryPayload(TEST_ABI, {
+            function: 'address_as_input',
+            arguments: ['0x1', '0x2'],
+            type_arguments: [],
+        });
+
+        // no need to run, type check only.
+        () => {
+            createEntryPayload(TEST_ABI, {
+                function: 'address_as_input',
+                arguments: [
+                    // @ts-expect-error invalid address
+                    1,
+                    // @ts-expect-error invalid address
+                    '1',
+                ],
+                type_arguments: [],
+            });
+        }
+    });
+
+    it('vector', async () => {
+        createEntryPayload(TEST_ABI, {
+            function: 'vector_as_input',
+            arguments: [
+                [],
+                [1, 2, 3],
+                [BigInt(1), BigInt(2), BigInt(3)],
+                [true, false, true],
+                ['0x1', '0x2', '0x3']
+            ],
+            type_arguments: [],
+        });
+
+        // no need to run, type check only.
+        () => {
+            createEntryPayload(TEST_ABI, {
+                function: 'vector_as_input',
+                arguments: [
+                    // @ts-expect-error invalid vector<u8>
+                    [1, 2, '3'],
+                    // @ts-expect-error invalid vector<u16>
+                    [1, 2, '3'],
+                    // @ts-expect-error invalid vector<u64>
+                    true,
+                    // @ts-expect-error invalid vector<bool>
+                    [true, false, 1],
+                    // @ts-expect-error invalid vector<address>
+                    ['0x1', '0x2', 1],
+                ],
+                type_arguments: [],
+            });
+        }
+    });
+
+    it('vector of vector', async () => {
+        createEntryPayload(TEST_ABI, {
+            function: 'vector_of_vector_as_input',
+            arguments: [
+                [[1, 2], [3, 4], [5, 6]],
+                [['0x1', '0x2'], ['0x3', '0x4'], ['0x5', '0x6']]
+            ],
+            type_arguments: [],
+        });
+
+        // no need to run, type check only.
+        () => {
+            createEntryPayload(TEST_ABI, {
+                function: 'vector_of_vector_as_input',
+                arguments: [
+                    // @ts-expect-error invalid vector<vector<u8>>
+                    [[], 1, 2, '3'],
+                    // @ts-expect-error invalid vector<vector<address>>
+                    [[], 1, 2, '3'],
+                ],
+                type_arguments: [],
+            });
+        }
+    });
+});
+
+const TEST_ABI = {
+    "address": "0x123",
+    "name": "test",
+    "friends": [],
+    "exposed_functions": [
+        {
+            "name": "address_as_input",
+            "visibility": "public",
+            "is_entry": true,
+            "is_view": false,
+            "generic_type_params": [],
+            "params": [
+                "address",
+                "address",
+            ],
+            "return": []
+        },
+        {
+            "name": "bool_as_input",
+            "visibility": "public",
+            "is_entry": true,
+            "is_view": false,
+            "generic_type_params": [],
+            "params": [
+                "bool",
+                "bool",
+            ],
+            "return": []
+        },
+        {
+            "name": "number_as_input",
+            "visibility": "public",
+            "is_entry": true,
+            "is_view": false,
+            "generic_type_params": [],
+            "params": [
+                "u8",
+                "u16",
+                "u32",
+                "u64",
+                "u128",
+                "u256",
+            ],
+            "return": []
+        },
+        {
+            "name": "vector_as_input",
+            "visibility": "public",
+            "is_entry": true,
+            "is_view": false,
+            "generic_type_params": [],
+            "params": [
+                "vector<u8>",
+                "vector<u16>",
+                "vector<u64>",
+                "vector<bool>",
+                "vector<address>",
+            ],
+            "return": []
+        },
+        {
+            "name": "vector_of_vector_as_input",
+            "visibility": "public",
+            "is_entry": true,
+            "is_view": false,
+            "generic_type_params": [],
+            "params": [
+                "vector<vector<u8>>",
+                "vector<vector<address>>",
+            ],
+            "return": []
+        },
+    ],
+
+    "structs": []
+} as const;

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

@@ -0,0 +1,297 @@
+import { COIN_ABI } from '../../abi/coin';
+import { createViewPayload } from '../createViewPayload';
+
+// TODO: add struct, vector of vector
+describe('createViewPayload', () => {
+  // Act before assertions
+  beforeAll(async () => { });
+
+  // Teardown (cleanup) after assertions
+  afterAll(() => { });
+
+  it('basic type checking', async () => {
+    // no need to run, type check only.
+    () => {
+      createViewPayload(COIN_ABI, {
+        // @ts-expect-error abc is not a function
+        function: 'abc',
+        arguments: ['0x1'],
+        type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      });
+
+      createViewPayload(COIN_ABI, {
+        // @ts-expect-error transfer is not a view function
+        function: 'transfer',
+        arguments: ['0x1'],
+        type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      });
+
+      createViewPayload(COIN_ABI, {
+        function: 'balance',
+        // @ts-expect-error require a address type
+        arguments: [''],
+        type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      });
+
+      createViewPayload(COIN_ABI, {
+        function: 'balance',
+        // @ts-expect-error require 1 args
+        arguments: ['0x1', 1],
+        type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      });
+
+      createViewPayload(COIN_ABI, {
+        function: 'balance',
+        arguments: ['0x1'],
+        // @ts-expect-error require a type_argument
+        type_arguments: [],
+      });
+    }
+  });
+
+  it('basic', async () => {
+    const payload = createViewPayload(COIN_ABI, {
+      function: 'balance',
+      arguments: ['0x1'],
+      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+    });
+
+    expect(payload).toMatchInlineSnapshot(`
+      {
+        "decoders": [
+          [Function],
+        ],
+        "viewRequest": {
+          "arguments": [
+            "0x1",
+          ],
+          "function": "0x1::coin::balance",
+          "type_arguments": [
+            "0x1::aptos_coin::AptosCoin",
+          ],
+        },
+      }
+    `);
+  });
+
+  it('bool', async () => {
+    // no need to run, type check only.
+    () => {
+      createViewPayload(TEST_ABI, {
+        function: 'bool_as_input',
+        arguments: [
+          // @ts-expect-error not a boolean type
+          1,
+          // @ts-expect-error not a boolean type
+          'false',
+        ],
+        type_arguments: [],
+      });
+    }
+
+    const payload = createViewPayload(TEST_ABI, {
+      function: 'bool_as_input',
+      arguments: [true, false],
+      type_arguments: [],
+    });
+
+    expect(payload).toMatchInlineSnapshot(`
+      {
+        "decoders": [],
+        "viewRequest": {
+          "arguments": [
+            true,
+            false,
+          ],
+          "function": "0x123::test::bool_as_input",
+          "type_arguments": [],
+        },
+      }
+    `);
+  });
+
+  it('address', async () => {
+    // no need to run, type check only.
+    () => {
+      createViewPayload(TEST_ABI, {
+        function: 'address_as_input',
+        arguments: [
+          // @ts-expect-error not a address type
+          1,
+          // @ts-expect-error not a address type
+          '1',
+        ],
+        type_arguments: [],
+      });
+    }
+
+    const payload = createViewPayload(TEST_ABI, {
+      function: 'address_as_input',
+      arguments: ['0x1', '0x2'],
+      type_arguments: [],
+    });
+
+    expect(payload).toMatchInlineSnapshot(`
+      {
+        "decoders": [],
+        "viewRequest": {
+          "arguments": [
+            "0x1",
+            "0x2",
+          ],
+          "function": "0x123::test::address_as_input",
+          "type_arguments": [],
+        },
+      }
+    `);
+  });
+
+  it('number', async () => {
+    // no need to run, type check only.
+    () => {
+      createViewPayload(TEST_ABI, {
+        function: 'number_as_input',
+        arguments: [
+          // @ts-expect-error not a number type
+          '1',
+          // @ts-expect-error not a number type
+          true,
+        ],
+        type_arguments: [],
+      });
+    }
+
+    const payload = createViewPayload(TEST_ABI, {
+      function: 'number_as_input',
+      arguments: [1, 2, 3, BigInt(5), BigInt(6), BigInt(7)],
+      type_arguments: [],
+    });
+
+    expect(payload).toMatchInlineSnapshot(`
+      {
+        "decoders": [],
+        "viewRequest": {
+          "arguments": [
+            1,
+            2,
+            3,
+            "5",
+            "6",
+            "7",
+          ],
+          "function": "0x123::test::number_as_input",
+          "type_arguments": [],
+        },
+      }
+    `);
+  });
+
+  it('vector', async () => {
+    const payload = createViewPayload(TEST_ABI, {
+      function: 'vector_as_input',
+      arguments: [
+        [1, 2, 3],
+        [4, 5, 6],
+        [BigInt(10000000000000000000001), BigInt(10000000000000000000001)],
+        [true, false],
+        ['0x1', '0x2'],
+      ],
+      type_arguments: [],
+    });
+
+    expect(payload).toMatchInlineSnapshot(`
+      {
+        "decoders": [],
+        "viewRequest": {
+          "arguments": [
+            "0x010203",
+            [
+              4,
+              5,
+              6,
+            ],
+            [
+              "10000000000000000000000",
+              "10000000000000000000000",
+            ],
+            [
+              true,
+              false,
+            ],
+            [
+              "0x1",
+              "0x2",
+            ],
+          ],
+          "function": "0x123::test::vector_as_input",
+          "type_arguments": [],
+        },
+      }
+    `);
+  });
+});
+
+const TEST_ABI = {
+  "address": "0x123",
+  "name": "test",
+  "friends": [],
+  "exposed_functions": [
+    {
+      "name": "bool_as_input",
+      "visibility": "public",
+      "is_entry": false,
+      "is_view": true,
+      "generic_type_params": [],
+      "params": [
+        "bool",
+        "bool",
+      ],
+      "return": []
+    },
+    {
+      "name": "number_as_input",
+      "visibility": "public",
+      "is_entry": false,
+      "is_view": true,
+      "generic_type_params": [],
+      "params": [
+        "u8",
+        "u16",
+        "u32",
+        "u64",
+        "u128",
+        "u256",
+      ],
+      "return": []
+    },
+    {
+      "name": "address_as_input",
+      "visibility": "public",
+      "is_entry": false,
+      "is_view": true,
+      "generic_type_params": [],
+      "params": [
+        "address",
+        "address",
+      ],
+      "return": []
+    },
+    {
+      "name": "vector_as_input",
+      "visibility": "public",
+      "is_entry": false,
+      "is_view": true,
+      "generic_type_params": [],
+      "params": [
+        "vector<u8>",
+        "vector<u16>",
+        "vector<u64>",
+        "vector<bool>",
+        "vector<address>",
+      ],
+      "return": []
+    },
+
+  ],
+  "structs": []
+} as const;