@thalalabs/surf 0.0.12 → 0.0.14

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

@@ -4,10 +4,10 @@ import { createViewPayload } from '../createViewPayload';
 // TODO: add struct, vector of vector
 describe('createViewPayload', () => {
   // Act before assertions
-  beforeAll(async () => { });
+  beforeAll(async () => {});
 
   // Teardown (cleanup) after assertions
-  afterAll(() => { });
+  afterAll(() => {});
 
   it('basic type checking', async () => {
     // no need to run, type check only.
@@ -46,7 +46,7 @@ describe('createViewPayload', () => {
         // @ts-expect-error require a type_argument
         type_arguments: [],
       });
-    }
+    };
   });
 
   it('basic', async () => {
@@ -87,7 +87,7 @@ describe('createViewPayload', () => {
         ],
         type_arguments: [],
       });
-    }
+    };
 
     const payload = createViewPayload(TEST_ABI, {
       function: 'bool_as_input',
@@ -123,7 +123,7 @@ describe('createViewPayload', () => {
         ],
         type_arguments: [],
       });
-    }
+    };
 
     const payload = createViewPayload(TEST_ABI, {
       function: 'address_as_input',
@@ -159,7 +159,7 @@ describe('createViewPayload', () => {
         ],
         type_arguments: [],
       });
-    }
+    };
 
     const payload = createViewPayload(TEST_ABI, {
       function: 'number_as_input',
@@ -232,66 +232,52 @@ describe('createViewPayload', () => {
 });
 
 const TEST_ABI = {
-  "address": "0x123",
-  "name": "test",
-  "friends": [],
-  "exposed_functions": [
+  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: '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: '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: '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>",
+      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": []
+      return: [],
     },
-
   ],
-  "structs": []
+  structs: [],
 } as const;

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

@@ -112,7 +112,7 @@ describe('option type', () => {
         arguments: [[1, 2]],
         type_arguments: [],
       });
-    }
+    };
   }, 60000);
 });
 

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

@@ -25,49 +25,49 @@ describe('useABI', () => {
   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'],
-        });
-      }
+      // @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 () => {
@@ -92,6 +92,19 @@ describe('useABI', () => {
     `);
   }, 60000);
 
+  it('view with ledger version', async () => {
+    const result = await client.useABI(COIN_ABI).view.balance({
+      arguments: ['0x1'],
+      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      ledger_version: '562606728',
+    });
+    expect(result).toMatchInlineSnapshot(`
+      [
+        50000358n,
+      ]
+    `);
+  }, 60000);
+
   it('entry', async () => {
     const result = await client.useABI(COIN_ABI).entry.transfer({
       arguments: ['0x1', 1],
@@ -117,23 +130,19 @@ describe('useABI', () => {
 });
 
 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;
-  
+  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

@@ -7,84 +7,100 @@ import { createClient } from '../Client';
 import { createViewPayload } from '../createViewPayload';
 
 describe('call view functions', () => {
-    const client = createClient({
-        nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
-    });
+  const client = createClient({
+    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
+  });
 
-    const clientMain = createClient({
-        nodeUrl: 'https://fullnode.mainnet.aptoslabs.com/v1',
-    });
+  const clientMain = createClient({
+    nodeUrl: 'https://fullnode.mainnet.aptoslabs.com/v1',
+  });
 
-    // Act before assertions
-    beforeAll(async () => { });
+  // Act before assertions
+  beforeAll(async () => {});
 
-    // Teardown (cleanup) after assertions
-    afterAll(() => { });
+  // 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(`
+  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(`
+    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);
+  }, 60000);
 
-    it('return struct', async () => {
-        const viewPayload = createViewPayload(TIERED_ORACLE_ABI, {
-            function: 'get_last_price',
-            arguments: [],
-            type_arguments: ['0x1::aptos_coin::AptosCoin'],
-        });
+  it('ledger version', async () => {
+    const viewPayload = createViewPayload(COIN_ABI, {
+      function: 'balance',
+      arguments: ['0x1'],
+      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+    });
+    const result = await client.view(viewPayload, {
+      ledger_version: '562606728',
+    });
+    expect(result).toMatchInlineSnapshot(`
+      [
+        50000358n,
+      ]
+    `);
+  }, 60000);
+
+  it('return 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);
+    // 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 TIERED_ORACLE_ABI = {
-    address: '0x92e95ed77b5ac815d3fbc2227e76db238339e9ca43ace45031ec2589bea5b8c',
-    name: 'tiered_oracle',
-    friends: [
-        '0x92e95ed77b5ac815d3fbc2227e76db238339e9ca43ace45031ec2589bea5b8c::oracle',
-    ],
-    exposed_functions: [
+  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: [
         {
-            name: 'get_last_price',
-            visibility: 'public',
-            is_entry: false,
-            is_view: true,
-            generic_type_params: [
-                {
-                    constraints: [],
-                },
-            ],
-            params: [],
-            return: [
-                '0x4dcae85fc5559071906cd5c76b7420fcbb4b0a92f00ab40ffc394aadbbff5ee9::fixed_point64::FixedPoint64',
-            ],
+          constraints: [],
         },
-    ],
-    structs: [],
+      ],
+      params: [],
+      return: [
+        '0x4dcae85fc5559071906cd5c76b7420fcbb4b0a92f00ab40ffc394aadbbff5ee9::fixed_point64::FixedPoint64',
+      ],
+    },
+  ],
+  structs: [],
 } as const;

package/src/core/createEntryPayload.ts

@@ -139,11 +139,12 @@ function argToBCS(type: string, arg: any, serializer: BCS.Serializer) {
 
   const optionRegex = /0x1::option::Option<([^]+)>/;
   const optionMatch = type.match(optionRegex);
-  if (optionMatch) { // It's 0x1::option::Option
+  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.');
+    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;

package/src/core/index.ts

@@ -1,4 +1,3 @@
-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/ensureTypes.ts

@@ -1,42 +1,45 @@
 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}`,
-        );
-    }
+  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;
-    }
+  assertType(val, ['boolean', 'string']);
+  if (typeof val === 'boolean') {
+    return val;
+  }
 
-    if (val === "true") {
-        return true;
-    }
-    if (val === "false") {
-        return false;
-    }
+  if (val === 'true') {
+    return true;
+  }
+  if (val === 'false') {
+    return false;
+  }
 
-    throw new Error("Invalid boolean string.");
+  throw new Error('Invalid boolean string.');
 }
 
 export function ensureNumber(val: number | string): number {
-    assertType(val, ["number", "string"]);
-    if (typeof val === "number") {
-        return val;
-    }
+  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.");
-    }
+  const res = Number.parseInt(val, 10);
+  if (Number.isNaN(res)) {
+    throw new Error('Invalid number string.');
+  }
 
-    return res;
+  return res;
 }
 
 export function ensureBigInt(val: number | bigint | string): bigint {
-    assertType(val, ["number", "bigint", "string"]);
-    return BigInt(val);
-}
+  assertType(val, ['number', 'bigint', 'string']);
+  return BigInt(val);
+}

package/src/hooks/useWalletClient.ts

@@ -1,12 +1,12 @@
 import { useWallet } from '@aptos-labs/wallet-adapter-react';
-import { MoveTsWalletClient } from '../core/index.js';
+import { WalletClient } from '../core/WalletClient.js';
 
 export const useWalletClient = ({ nodeUrl }: { nodeUrl: string }) => {
   const wallet = useWallet();
   return {
     connected: wallet.connected,
     client: wallet.connected
-      ? new MoveTsWalletClient({ wallet, nodeUrl })
+      ? new WalletClient({ wallet, nodeUrl })
       : undefined,
   };
 };

package/src/index.ts

@@ -1,11 +1,11 @@
 export {
-    createViewPayload,
-    createEntryPayload,
-    createClient
-} from "./core/index.js";
+  createViewPayload,
+  createEntryPayload,
+  createClient,
+} from './core/index.js';
 
 export type {
-    EntryPayload,
-    ViewPayload,
-    DefaultABITable
-} from "./types/index.js";
+  EntryPayload,
+  ViewPayload,
+  DefaultABITable,
+} from './types/index.js';

package/src/types/client/abiClient.ts

@@ -24,6 +24,7 @@ export type ABIViewClient<T extends ABIRoot> = {
   [TFuncName in ViewFunctionName<T>]: (payload: {
     type_arguments: ExtractGenericArgsType<T, TFuncName>;
     arguments: ExtractArgsType<T, TFuncName>;
+    ledger_version?: string;
   }) => Promise<ExtractReturnType<T, TFuncName>>;
 };
 
@@ -40,6 +41,7 @@ export type ABIResourceClient<TABITable extends ABITable, T extends ABIRoot> = {
   [TStructName in ResourceStructName<T>]: (payload: {
     type_arguments: ExtractStructGenericArgsType<T, TStructName>;
     account: `0x${string}`;
+    ledger_version?: string;
   }) => Promise<{
     data: ExtractStructType<TABITable, T, TStructName>;
     type: string;

package/src/types/convertor/argsConvertor.ts

@@ -55,5 +55,5 @@ type ConvertNonStructArgType<TMoveType extends MoveNonStructTypes> =
     : TMoveType extends `0x1::object::Object<${string}>`
     ? `0x${string}`
     : TMoveType extends `0x1::option::Option<${infer TInner}>`
-    ? ([ConvertArgType<TInner>] | [])
+    ? [ConvertArgType<TInner>] | []
     : UnknownStruct<TMoveType>;