@thalalabs/surf 0.0.3 → 0.0.5

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

@@ -0,0 +1,223 @@
+/**
+ * These test cases depends on network, it call the real contract.
+ */
+
+import { createClient } from '../Client';
+import { createViewPayload } from '../createViewPayload';
+
+// TODO: add vector<address>, vector<struct>
+describe('call view functions for vector type', () => {
+  const client = createClient({
+    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
+  });
+
+  // Act before assertions
+  beforeAll(async () => {});
+
+  // Teardown (cleanup) after assertions
+  afterAll(() => {});
+
+  it('vector_bool', async () => {
+    const viewPayload = createViewPayload(TEST_ABI, {
+      function: 'test_view_function_bool',
+      arguments: [[true, false, false, true, true]],
+      type_arguments: [],
+    });
+    const result = await client.view(viewPayload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        3,
+      ]
+    `);
+  }, 60000);
+
+  it('vector_u8', async () => {
+    const viewPayload = createViewPayload(TEST_ABI, {
+      function: 'test_view_function_u8',
+      arguments: [[1, 2, 3, 10, 50]],
+      type_arguments: [],
+    });
+    const result = await client.view(viewPayload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        66,
+      ]
+    `);
+  }, 60000);
+
+  it('vector_u16', async () => {
+    const viewPayload = createViewPayload(TEST_ABI, {
+      function: 'test_view_function_u16',
+      arguments: [[256, 100]],
+      type_arguments: [],
+    });
+    const result = await client.view(viewPayload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        356,
+      ]
+    `);
+  }, 60000);
+
+  it('vector_u32', async () => {
+    const viewPayload = createViewPayload(TEST_ABI, {
+      function: 'test_view_function_u32',
+      arguments: [[70000, 100]],
+      type_arguments: [],
+    });
+    const result = await client.view(viewPayload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        70100,
+      ]
+    `);
+  }, 60000);
+
+  it('vector_u64', async () => {
+    const viewPayload = createViewPayload(TEST_ABI, {
+      function: 'test_view_function_u64',
+      arguments: [[BigInt('4294967296'), 100]],
+      type_arguments: [],
+    });
+    const result = await client.view(viewPayload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        4294967396n,
+      ]
+    `);
+  }, 60000);
+
+  it('vector_u256', async () => {
+    const viewPayload = createViewPayload(TEST_ABI, {
+      function: 'test_view_function_u256',
+      arguments: [[BigInt('4294967296'), 100]],
+      type_arguments: [],
+    });
+    const result = await client.view(viewPayload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        4294967396n,
+      ]
+    `);
+  }, 60000);
+
+  it('return vector', async () => {
+    const viewPayload = createViewPayload(TEST_ABI, {
+      function: 'test_view_function_u64_return_vector',
+      arguments: [[BigInt('4294967296'), 100]],
+      type_arguments: [],
+    });
+    const result = await client.view(viewPayload);
+    expect(result).toMatchInlineSnapshot(`
+      [
+        [
+          4294967296n,
+          100n,
+        ],
+      ]
+    `);
+  }, 60000);
+});
+
+const TEST_ABI = {
+  address: '0xf1ab5cd814ef1480b8c36466310d9c21d7758b54f6121872d1fb43887a40e7d8',
+  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_bool',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['vector<bool>'],
+      return: ['u32'],
+    },
+    {
+      name: 'test_view_function_u128',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['vector<u128>'],
+      return: ['u128'],
+    },
+    {
+      name: 'test_view_function_u16',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['vector<u16>'],
+      return: ['u16'],
+    },
+    {
+      name: 'test_view_function_u256',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['vector<u256>'],
+      return: ['u256'],
+    },
+    {
+      name: 'test_view_function_u32',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['vector<u32>'],
+      return: ['u32'],
+    },
+    {
+      name: 'test_view_function_u64',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['vector<u64>'],
+      return: ['u64'],
+    },
+    {
+      name: 'test_view_function_u64_return_vector',
+      visibility: 'public',
+      is_entry: false,
+      is_view: true,
+      generic_type_params: [],
+      params: ['vector<u64>'],
+      return: ['vector<u64>'],
+    },
+    {
+      name: 'test_view_function_u8',
+      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/createEntryPayload.ts

@@ -1,7 +1,7 @@
 import { BCS, TxnBuilderTypes, TypeTagParser } from "aptos";
-import { ensureBigInt, ensureBoolean, ensureNumber } from "../ensureTypes";
-import { ABIRoot, EntryPayload } from "../types";
-import { EntryFunctionName, EntryRequestPayload } from "../types/common";
+import { ensureBigInt, ensureBoolean, ensureNumber } from "../ensureTypes.js";
+import type { ABIRoot, EntryPayload } from "../types/index.js";
+import type { EntryFunctionName, EntryRequestPayload } from "../types/common.js";
 
 export function createEntryPayload<
     T extends ABIRoot,
@@ -11,7 +11,7 @@ export function createEntryPayload<
     payload: EntryRequestPayload<T, TFuncName>
 ): EntryPayload {
     // TODO: remove unused variables
-    const fnAbi = abi.exposed_functions.filter(f => f.name === payload.function)[0];
+    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'
@@ -53,7 +53,7 @@ export function createEntryPayload<
                 }),
             valArguments.map( // arguments
                 (arg, i) => {
-                    const type = abiArgs[i];
+                    const type = abiArgs[i]!;
                     const serializer = new BCS.Serializer();
                     argToBCS(type, arg, serializer);
                     return serializer.getBytes();
@@ -69,7 +69,7 @@ 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];
+        const innerType = match[1]!;
         if (innerType === 'u8') {
             if (arg instanceof Uint8Array) { // TODO: add type support for Uint8Array
                 serializer.serializeBytes(arg);

package/src/core/createViewPayload.ts

@@ -1,7 +1,7 @@
 import { HexString } from "aptos";
-import { ABIRoot, ViewPayload } from "../types";
-import { ExtractReturnType, ViewFunctionName, ViewRequestPayload } from "../types/common";
-import { ensureNumber } from "../ensureTypes";
+import type { ABIRoot, ViewPayload } from "../types/index.js";
+import type { ExtractReturnType, ViewFunctionName, ViewRequestPayload } from "../types/common.js";
+import { ensureNumber } from "../ensureTypes.js";
 
 // TODO: support vector<u8> input with Uint8Array
 // TODO: support vector<u8> input with string
@@ -24,17 +24,18 @@ export function createViewPayload<
 
     // TODO: do serialization here
     const args = fnAbi.params.map((type, i) => {
+        const arg = payload.arguments[i]!;
         if (['u8', 'u16', 'u32'].includes(type)) {
-            return ensureNumber(payload.arguments[i] as number);
+            return ensureNumber(arg as number);
         }
         else if (['u64', 'u128', 'u256'].includes(type)) {
-            return payload.arguments[i].toString();
+            return arg.toString();
         }
         else if (type.includes("vector")) {
-            return encodeVector(type, payload.arguments[i] as any[]);
+            return encodeVector(type, arg as any[]);
         }
         else {
-            return payload.arguments[i];
+            return arg;
         }
     });
 
@@ -43,6 +44,9 @@ export function createViewPayload<
         if (['u64', 'u128', 'u256'].includes(type)) {
             return decodeBigint;
         }
+        else if (type.includes("vector")) {
+            return (value: any[]) => decodeVector(type, value)
+        }
         else {
             return null;
         }
@@ -62,15 +66,36 @@ function decodeBigint(value: string): bigint {
     return BigInt(value);
 }
 
-function encodeVector(type: string, value: any[]) {
+function decodeVector(type: string, value: any[]) {
     const regex = /vector<([^]+)>/;
     const match = type.match(regex);
     if (!match) {
         // Should never happen
         throw new Error(`Unsupported type: ${type}`);
     }
+    const innerType = match[1]!;
+
+    if(["address", "bool", "u8", "u16", "u32"].includes(innerType)) {
+        return value;
+    }
+    else if (["u64", "u128", "u256"].includes(innerType)) {
+        return value.map((v: string) => BigInt(v));
+    } else {
+        // 1. TODO: Figure out how to decode Struct type
+        // 2. TODO: Figure out how to decode Vector of vector, vector of struct
+        return value;
+    }
+}
 
-    if (match[1] === "u8") {
+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}`);
+    }
+    const innerType = match[1]!;
+    if (innerType === "u8") {
         return (
             HexString.fromUint8Array(
                 new Uint8Array(
@@ -83,18 +108,14 @@ function encodeVector(type: string, value: any[]) {
                 ),
             ) as any
         ).hexString;
-    } else if (["u16", "u32"].includes(match[1])) {
-        // TODO: Figure out how to encode
+    } else if (["bool", "u16", "u32"].includes(innerType)) {
         return value;
-    } else if (["u64", "u128", "u256"].includes(match[1])) {
-        // TODO: Figure out how to encode
+    } else if (["u64", "u128", "u256"].includes(innerType)) {
         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
+        // 3. TODO: Figure out how to encode Vector of vector, vector of struct
         return value;
     }
 }

package/src/core/index.ts

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

package/src/hooks/index.ts

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

package/src/hooks/useSubmitTransaction.ts

@@ -1,7 +1,7 @@
 import { useState, useRef } from "react";
 import { useWallet } from "@aptos-labs/wallet-adapter-react";
 import { AptosClient, Types } from "aptos";
-import { EntryPayload } from "../types";
+import type { EntryPayload } from "../types/index.js";
 
 export type submitTransactionOptions = {
     nodeUrl: string,

package/src/hooks/useWalletClient.ts

@@ -1,5 +1,5 @@
 import { useWallet } from "@aptos-labs/wallet-adapter-react";
-import { MoveTsWalletClient } from "../core";
+import { MoveTsWalletClient } from "../core/index.js";
 
 export const useWalletClient = ({ nodeUrl }: { nodeUrl: string }) => {
     const wallet = useWallet();

package/src/index.ts

@@ -2,9 +2,9 @@ export {
     createViewPayload,
     createEntryPayload,
     createClient
-} from "./core";
+} from "./core/index.js";
 
-export {
+export type {
     EntryPayload,
     ViewPayload,
-} from "./types";
+} from "./types/index.js";

package/src/types/abiClient.ts

@@ -1,6 +1,14 @@
-import { AptosAccount } from "aptos";
-import { ABIRoot } from "./abi";
-import { EntryFunctionName, ExtractGenericParamsType, ExtractParamsType, ExtractParamsTypeOmitSigner, ExtractReturnType, TransactionResponse, ViewFunctionName } from "./common";
+import type { AptosAccount } from "aptos";
+import type { ABIRoot } from "./abi.js";
+import type {
+    EntryFunctionName,
+    ExtractGenericParamsType,
+    ExtractParamsType,
+    ExtractParamsTypeOmitSigner,
+    ExtractReturnType,
+    TransactionResponse,
+    ViewFunctionName
+} from "./common.js";
 
 export type ABIViewClient<T extends ABIRoot> = {
     [TFuncName in ViewFunctionName<T>]: (payload: {

package/src/types/common.ts

@@ -1,4 +1,4 @@
-import { ABIRoot } from "./abi";
+import type { ABIRoot } from "./abi.js";
 
 // TODO: rename this variable, not only primitive, but also struct and vector
 export type Primitive =

package/src/types/index.ts

@@ -1,9 +1,9 @@
-export { ABIWalletClient } from "./walletClient";
-export { ABIViewClient, ABIEntryClient } from "./abiClient";
-export {
+export type { ABIWalletClient } from "./walletClient.js";
+export type { ABIViewClient, ABIEntryClient } from "./abiClient.js";
+export type {
     ViewPayload,
     EntryPayload,
     ViewOptions,
     EntryOptions,
-} from "./client";
-export { ABIRoot } from "./abi";
+} from "./client.js";
+export type { ABIRoot } from "./abi.js";

package/src/types/walletClient.ts

@@ -1,5 +1,5 @@
-import { ABIRoot } from "./abi";
-import { EntryFunctionName, ExtractGenericParamsType, ExtractParamsTypeOmitSigner, TransactionResponse } from "./common";
+import type { ABIRoot } from "./abi.js";
+import { EntryFunctionName, ExtractGenericParamsType, ExtractParamsTypeOmitSigner, TransactionResponse } from "./common.js";
 
 export type ABIWalletClient<T extends ABIRoot> = {
     [TFuncName in EntryFunctionName<T>]: