@thalalabs/surf 0.0.16 → 1.0.1

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

@@ -2,37 +2,40 @@
  * 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';
+import { createSurfClient } from '../Client.js';
+import { createEntryPayload } from '../createEntryPayload.js';
+import { Account, Aptos, AptosConfig, Ed25519PrivateKey, Network } from '@aptos-labs/ts-sdk';
 
 describe('call entry functions', () => {
-  const client = createClient({
-    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
-  });
-
-  const account = new AptosAccount(
-    undefined,
-    '0xac914efd2367c7aa42c95d100592c099e487d2270bf0e0761e5fe93ff4016593',
+  const client = createSurfClient(
+    new Aptos(
+      new AptosConfig({ network: Network.TESTNET })
+    )
   );
 
+  const account = Account.fromPrivateKey({ privateKey: new Ed25519PrivateKey("0x4b0a52d0b047b6868d9650fdb9b61720e361ba74f40571635fec0694a838eb98") });
+
   // Act before assertions
-  beforeAll(async () => {});
+  beforeAll(async () => { });
 
   // Teardown (cleanup) after assertions
-  afterAll(() => {});
+  afterAll(() => { });
 
   it('basic', async () => {
     const entryPayload = createEntryPayload(COIN_ABI, {
       function: 'transfer',
-      arguments: ['0x1', 1],
-      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      functionArguments: ['0x1', 1],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
     });
 
-    const result = await client.simulateTransaction(entryPayload, { account });
+    const result = await client.simulateTransaction({
+      payload: entryPayload,
+      sender: account.accountAddress,
+      publicKey: account.publicKey,
+    });
 
-    expect(result.hash).toBeDefined();
+    expect(result?.hash).toBeDefined();
     expect((result as any).payload).toMatchInlineSnapshot(`
       {
         "arguments": [
@@ -51,13 +54,17 @@ describe('call entry functions', () => {
   it('vector', async () => {
     const entryPayload = createEntryPayload(TEST_ABI, {
       function: 'test_run_function',
-      arguments: [[1, 2, 3, 10, 20, 30]],
-      type_arguments: [],
+      functionArguments: [[1, 2, 3, 10, 20, 30]],
+      typeArguments: [],
     });
 
-    const result = await client.simulateTransaction(entryPayload, { account });
+    const result = await client.simulateTransaction({
+      payload: entryPayload,
+      sender: account.accountAddress,
+      publicKey: account.publicKey,
+    });
 
-    expect(result.hash).toBeDefined();
+    expect(result?.hash).toBeDefined();
     expect((result as any).payload).toMatchInlineSnapshot(`
       {
         "arguments": [
@@ -71,20 +78,45 @@ describe('call entry functions', () => {
   }, 60000);
 
   it('vector<u8>', async () => {
-    const inputString = "a test string";
+    const inputString = [1,2,34];
+    const entryPayload = createEntryPayload(TEST_ABI, {
+      function: 'test_run_function',
+      functionArguments: [inputString],
+      typeArguments: [],
+    });
+
+    const result = await client.simulateTransaction({
+      payload: entryPayload,
+      sender: account.accountAddress,
+      publicKey: account.publicKey,
+    });
+
+    expect(result?.hash).toBeDefined();
+    expect((result as any).payload.arguments[0]).toEqual("0x010222");
+  }, 60000);
+
+
+  it('vector<u8> hex string', async () => {
+    const inputString = "0x1234";
     const entryPayload = createEntryPayload(TEST_ABI, {
       function: 'test_run_function',
-      arguments: [inputString],
-      type_arguments: [],
+      functionArguments: [inputString],
+      typeArguments: [],
     });
 
-    const result = await client.simulateTransaction(entryPayload, { account });
+    const result = await client.simulateTransaction({
+      payload: entryPayload,
+      sender: account.accountAddress,
+      publicKey: account.publicKey,
+    });
 
-    expect(result.hash).toBeDefined();
-    expect((result as any).payload.arguments[0]).toEqual("0x61207465737420737472696e67");
+    expect(result?.hash).toBeDefined();
+    expect((result as any).payload.arguments[0]).toEqual("0x1234");
   }, 60000);
 });
 
+
+
 const TEST_ABI = {
   address: '0x3d097bb505c9e5d8a96e367f371168240025877f6be8d4a88eacaafb709fe5c9',
   name: 'test',

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

@@ -2,78 +2,77 @@
  * 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 { createSurfClient } from '../Client';
+import { Account, Aptos, AptosConfig, Ed25519PrivateKey, Network } from '@aptos-labs/ts-sdk';
 
 describe('useABI', () => {
-  const client = createClient({
-    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
-  });
-
-  const account = new AptosAccount(
-    undefined,
-    '0xac914efd2367c7aa42c95d100592c099e487d2270bf0e0761e5fe93ff4016593',
+  const client = createSurfClient(
+    new Aptos(
+      new AptosConfig({ network: Network.TESTNET })
+    )
   );
 
+  const account = Account.fromPrivateKey({ privateKey: new Ed25519PrivateKey("0x4b0a52d0b047b6868d9650fdb9b61720e361ba74f40571635fec0694a838eb98") });
+
   // 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
     () => {
       // @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'],
+        functionArguments: ['0x1'],
+        typeArguments: ['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'],
+        functionArguments: ['0x1'],
+        typeArguments: ['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'],
+        typeArguments: ['0x1::aptos_coin::AptosCoin'],
       });
 
       client.useABI(TEST_ABI).view.address_as_input({
         // @ts-expect-error require two args
-        arguments: ['0x1'],
-        type_arguments: [],
+        functionArguments: ['0x1'],
+        typeArguments: [],
       });
 
       client.useABI(TEST_ABI).view.address_as_input({
         // @ts-expect-error require address
-        arguments: ['0x1', 1],
-        type_arguments: [],
+        functionArguments: ['0x1', 1],
+        typeArguments: [],
       });
 
       client.useABI(COIN_ABI).entry.transfer({
-        arguments: ['0x1', 1],
+        functionArguments: ['0x1', 1],
         // @ts-expect-error require a type argument
-        type_arguments: [],
+        typeArguments: [],
         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'],
+        functionArguments: ['0x1', 1],
+        typeArguments: ['0x1::aptos_coin::AptosCoin'],
       });
     };
   });
 
   it('view', async () => {
     const result = await client.useABI(COIN_ABI).view.name({
-      arguments: [],
-      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      functionArguments: [],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
     });
     expect(result).toMatchInlineSnapshot(`
       [
@@ -82,8 +81,8 @@ describe('useABI', () => {
     `);
 
     const result2 = await client.useABI(COIN_ABI).view.decimals({
-      arguments: [],
-      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      functionArguments: [],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
     });
     expect(result2).toMatchInlineSnapshot(`
       [
@@ -94,25 +93,26 @@ describe('useABI', () => {
 
   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',
+      functionArguments: ['0x1'],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
+      ledgerVersion: '562606728',
     });
     expect(result).toMatchInlineSnapshot(`
-      [
-        50000358n,
-      ]
-    `);
+[
+  "50000358",
+]
+`);
   }, 60000);
 
   it('entry', async () => {
     const result = await client.useABI(COIN_ABI).entry.transfer({
-      arguments: ['0x1', 1],
-      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      functionArguments: ['0x1', 1],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
       account,
       isSimulation: true,
     });
-    expect(result.hash).toBeDefined();
+    
+    expect(result?.hash).toBeDefined();
     expect((result as any).payload).toMatchInlineSnapshot(`
       {
         "arguments": [

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

@@ -2,32 +2,36 @@
  * 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';
+import { Aptos, AptosConfig, Network } from '@aptos-labs/ts-sdk';
+import { COIN_ABI } from '../../abi/coin.js';
+import { createSurfClient } from '../Client.js';
+import { createViewPayload } from '../createViewPayload.js';
 
 describe('call view functions', () => {
-  const client = createClient({
-    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
-  });
-
-  const clientMain = createClient({
-    nodeUrl: 'https://fullnode.mainnet.aptoslabs.com/v1',
-  });
-
+  const client = createSurfClient(
+    new Aptos(
+      new AptosConfig({ network: Network.TESTNET })
+    )
+  );
+  
+  const clientMain = createSurfClient(
+    new Aptos(
+      new AptosConfig({ network: Network.MAINNET })
+    )
+  );
   // Act before assertions
-  beforeAll(async () => {});
+  beforeAll(async () => { });
 
   // Teardown (cleanup) after assertions
-  afterAll(() => {});
+  afterAll(() => { });
 
   it('basic', async () => {
     const viewPayload = createViewPayload(COIN_ABI, {
       function: 'name',
-      arguments: [],
-      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      functionArguments: [],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
       [
         "Aptos Coin",
@@ -36,10 +40,10 @@ describe('call view functions', () => {
 
     const viewPayload2 = createViewPayload(COIN_ABI, {
       function: 'decimals',
-      arguments: [],
-      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      functionArguments: [],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
     });
-    const result2 = await client.view(viewPayload2);
+    const result2 = await client.view({ payload: viewPayload2 });
     expect(result2).toMatchInlineSnapshot(`
       [
         8,
@@ -50,29 +54,31 @@ describe('call view functions', () => {
   it('ledger version', async () => {
     const viewPayload = createViewPayload(COIN_ABI, {
       function: 'balance',
-      arguments: ['0x1'],
-      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      functionArguments: ['0x1'],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
     });
-    const result = await client.view(viewPayload, {
-      ledger_version: '562606728',
+    const result = await client.view({
+      payload: viewPayload, options: {
+        ledgerVersion: 562606728,
+      }
     });
     expect(result).toMatchInlineSnapshot(`
-      [
-        50000358n,
-      ]
-    `);
+[
+  "50000358",
+]
+`);
   }, 60000);
 
   it('return struct', async () => {
     const viewPayload = createViewPayload(TIERED_ORACLE_ABI, {
       function: 'get_last_price',
-      arguments: [],
-      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      functionArguments: [],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
     });
 
     // The declaration in Move:
     // struct FixedPoint64 has copy, drop, store { value: u128 }
-    const result = await clientMain.view(viewPayload);
+    const result = await clientMain.view({ payload: viewPayload });
     expect(result.length).toBe(1);
     expect((result[0] as any).v).toBeDefined();
     expect(typeof (result[0] as any).v).toEqual('string');

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

@@ -2,28 +2,30 @@
  * These test cases depends on network, it call the real contract.
  */
 
-import { createClient } from '../Client';
-import { createViewPayload } from '../createViewPayload';
+import { Aptos, AptosConfig, Network } from '@aptos-labs/ts-sdk';
+import { createSurfClient } from '../Client.js';
+import { createViewPayload } from '../createViewPayload.js';
 
 // TODO: add vector<address>, vector<vector>
 describe('call view functions for vector type', () => {
-  const client = createClient({
-    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
-  });
-
+  const client = createSurfClient(
+    new Aptos(
+      new AptosConfig({ network: Network.TESTNET })
+    )
+  );
   // Act before assertions
-  beforeAll(async () => {});
+  beforeAll(async () => { });
 
   // Teardown (cleanup) after assertions
-  afterAll(() => {});
+  afterAll(() => { });
 
   it('vector_bool', async () => {
     const viewPayload = createViewPayload(TEST_ABI, {
       function: 'test_view_function_bool',
-      arguments: [[true, false, false, true, true]],
-      type_arguments: [],
+      functionArguments: [[true, false, false, true, true]],
+      typeArguments: [],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
       [
         3,
@@ -31,13 +33,13 @@ describe('call view functions for vector type', () => {
     `);
   }, 60000);
 
-  it('vector_u8', async () => {
+  it('vector_u8 array', async () => {
     const viewPayload = createViewPayload(TEST_ABI, {
       function: 'test_view_function_u8',
-      arguments: [[1, 2, 3, 10, 50]],
-      type_arguments: [],
+      functionArguments: [[1, 2, 3, 10, 50]],
+      typeArguments: [],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
       [
         66,
@@ -45,16 +47,16 @@ describe('call view functions for vector type', () => {
     `);
   }, 60000);
 
-  it('vector_u8', async () => {
+  it('vector_u8 string', async () => {
     const viewPayload = createViewPayload(TEST_ABI, {
       function: 'test_view_function_u8',
-      arguments: ["ab"],
-      type_arguments: [],
+      functionArguments: ["0x010234"],
+      typeArguments: [],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
     [
-      195,
+      55,
     ]
   `);
   }, 60000);
@@ -62,10 +64,10 @@ describe('call view functions for vector type', () => {
   it('vector_u16', async () => {
     const viewPayload = createViewPayload(TEST_ABI, {
       function: 'test_view_function_u16',
-      arguments: [[256, 100]],
-      type_arguments: [],
+      functionArguments: [[256, 100]],
+      typeArguments: [],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
       [
         356,
@@ -76,10 +78,10 @@ describe('call view functions for vector type', () => {
   it('vector_u32', async () => {
     const viewPayload = createViewPayload(TEST_ABI, {
       function: 'test_view_function_u32',
-      arguments: [[70000, 100]],
-      type_arguments: [],
+      functionArguments: [[70000, 100]],
+      typeArguments: [],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
       [
         70100,
@@ -90,46 +92,46 @@ describe('call view functions for vector type', () => {
   it('vector_u64', async () => {
     const viewPayload = createViewPayload(TEST_ABI, {
       function: 'test_view_function_u64',
-      arguments: [[BigInt('4294967296'), 100]],
-      type_arguments: [],
+      functionArguments: [[BigInt('4294967296'), 100]],
+      typeArguments: [],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
-      [
-        4294967396n,
-      ]
-    `);
+[
+  "4294967396",
+]
+`);
   }, 60000);
 
   it('vector_u256', async () => {
     const viewPayload = createViewPayload(TEST_ABI, {
       function: 'test_view_function_u256',
-      arguments: [[BigInt('4294967296'), 100]],
-      type_arguments: [],
+      functionArguments: [[BigInt('4294967296'), 100]],
+      typeArguments: [],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
-      [
-        4294967396n,
-      ]
-    `);
+[
+  "4294967396",
+]
+`);
   }, 60000);
 
   it('return vector', async () => {
     const viewPayload = createViewPayload(TEST_ABI, {
       function: 'test_view_function_u64_return_vector',
-      arguments: [[BigInt('4294967296'), 100]],
-      type_arguments: [],
+      functionArguments: [[BigInt('4294967296'), 100]],
+      typeArguments: [],
     });
-    const result = await client.view(viewPayload);
+    const result = await client.view({ payload: viewPayload });
     expect(result).toMatchInlineSnapshot(`
-      [
-        [
-          4294967296n,
-          100n,
-        ],
-      ]
-    `);
+[
+  [
+    "4294967296",
+    "100",
+  ],
+]
+`);
   }, 60000);
 });