@thalalabs/surf 0.0.16 → 1.0.0

package/src/core/createEntryPayload.ts

@@ -1,5 +1,3 @@
-import { BCS, TxnBuilderTypes, TypeTagParser } from 'aptos';
-import { ensureBigInt, ensureBoolean, ensureNumber } from '../ensureTypes.js';
 import type {
   ABIRoot,
   EntryPayload,
@@ -16,27 +14,33 @@ import { EntryFunctionName } from '../types/extractor/functionExtractor.js';
  * @param payload.type_arguments The generic type arguments for function.
  * @returns The payload object to be used in `simulateTransaction` or `submitTransaction` method.
  * @example
- * const entryPayload = createEntryPayload(COIN_ABI, {
- *     function: 'transfer',
- *     arguments: ['0x1', 1],
- *     type_arguments: ['0x1::aptos_coin::AptosCoin'],
+ * const payload = createEntryPayload(COIN_ABI, {
+ *   function: 'transfer',
+ *   functionArguments: ['0x1', 1],
+ *   typeArguments: ['0x1::aptos_coin::AptosCoin'],
  * });
  *
- * const { hash } = await client.submitTransaction(
- *     entryPayload,
- *     { account },
- * );
+ * const result = await client.submitTransaction({
+ *   payload,
+ *   signer: account,
+ * });
  */
 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[];
+  )[0];
+
+  if (fnAbi === undefined)
+    throw new Error(`Function ${payload.function} not found in ABI`);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const typeArguments: string[] = payload.typeArguments as any[];
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const valArguments: any[] = payload.functionArguments as any[];
   const abiArgs =
     fnAbi.params[0] === '&signer'
       ? (fnAbi.params as string[]).slice(1)
@@ -47,140 +51,17 @@ export function createEntryPayload<
     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`,
+      `Function ${payload.function} expects ${fnAbi.params.length} arguments, but ${payload.functionArguments.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`,
+      `Function ${payload.function} expects ${fnAbi.generic_type_params.length} type arguments, but ${payload.typeArguments.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();
-        },
-      ),
-    ),
+    typeArguments: payload.typeArguments,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    functionArguments: payload.functionArguments as any,
+    function: `${abi.address}::${abi.name}::${payload.function}`,
   };
 }
-
-function argToBCS(type: string, arg: any, serializer: BCS.Serializer) {
-  const vectorRegex = /vector<([^]+)>/;
-  const vectorMatch = type.match(vectorRegex);
-  if (vectorMatch) {
-    // It's vector
-    const innerType = vectorMatch[1]!;
-    if (innerType === 'u8') {
-      if (arg instanceof Uint8Array) {
-        serializer.serializeBytes(arg);
-        return;
-      }
-
-      if (typeof arg === '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;
-  }
-
-  const objectRegex = /0x1::object::Object<([^]+)>/;
-  const objectMatch = type.match(objectRegex);
-  if (objectMatch) {
-    // It's 0x1::object::Object
-    TxnBuilderTypes.AccountAddress.fromHex(arg as string).serialize(serializer);
-    return;
-  }
-
-  const optionRegex = /0x1::option::Option<([^]+)>/;
-  const optionMatch = type.match(optionRegex);
-  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.');
-    }
-    arg.forEach((arg) => argToBCS(innerType, arg, serializer));
-    return;
-  }
-
-  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

@@ -1,4 +1,3 @@
-import { HexString } from 'aptos';
 import {
   ABIRoot,
   ExtractReturnType,
@@ -7,9 +6,8 @@ import {
   ViewRequestPayload,
 } from '../types/index.js';
 import { ensureNumber } from '../ensureTypes.js';
+import { MoveStructId } from '@aptos-labs/ts-sdk';
 
-// TODO: support vector<u8> input with Uint8Array
-// TODO: support vector<u8> input with string
 /**
  * Create a payload for calling a view function.
  *
@@ -19,12 +17,12 @@ import { ensureNumber } from '../ensureTypes.js';
  * @param payload.type_arguments The generic type arguments for function.
  * @returns The payload object to be used in `view` method.
  * @example
- * const viewPayload = createViewPayload(COIN_ABI, {
+ * const payload = createViewPayload(COIN_ABI, {
  *   function: 'balance',
- *   arguments: ['0x1'],
- *   type_arguments: ['0x1::aptos_coin::AptosCoin'],
+ *   functionArguments: ['0x1'],
+ *   typeArguments: ['0x1::aptos_coin::AptosCoin'],
  * });
- * const [balance] = await client.view(viewPayload);
+ * const [balance] = await client.view({ payload });
  */
 export function createViewPayload<
   T extends ABIRoot,
@@ -36,24 +34,25 @@ export function createViewPayload<
   const fnAbi = abi.exposed_functions.filter(
     (f) => f.name === payload.function,
   )[0];
-  const type_arguments: string[] = payload.type_arguments;
-  const val_arguments: any[] = payload.arguments;
+  const type_arguments: string[] = payload.typeArguments;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const val_arguments: any[] = payload.functionArguments;
 
   // 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`,
+      `Function ${payload.function} expects ${fnAbi.params.length} arguments, but ${payload.functionArguments.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`,
+      `Function ${payload.function} expects ${fnAbi.generic_type_params.length} type arguments, but ${payload.functionArguments.length} were provided`,
     );
 
   // TODO: do serialization here
   const args = fnAbi.params.map((type, i) => {
-    const arg = payload.arguments[i] as unknown;
+    const arg = payload.functionArguments[i] as unknown;
     if (['u8', 'u16', 'u32'].includes(type)) {
       return ensureNumber(arg as number);
     } else if (['u64', 'u128', 'u256'].includes(type)) {
@@ -62,6 +61,7 @@ export function createViewPayload<
       }
       return arg.toString();
     } else if (type.includes('vector')) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       return encodeVector(type, arg as any[]);
     } else {
       // string or address
@@ -69,75 +69,35 @@ export function createViewPayload<
     }
   });
 
-  // used to decode the return value in response
-  const decoders = fnAbi.return.map((type) => {
-    if (['u64', 'u128', 'u256'].includes(type)) {
-      return decodeBigint;
-    } else if (type.includes('vector')) {
-      return (value: any[]) => decodeVector(type, value);
-    } else {
-      return null;
-    }
-  });
-
   return {
-    viewRequest: {
-      function: `${abi.address}::${abi.name}::${payload.function}`,
-      arguments: args,
-      type_arguments: payload.type_arguments as string[],
-    },
-    decoders,
+    function: `${abi.address}::${abi.name}::${payload.function}`,
+    functionArguments: args,
+    typeArguments: payload.typeArguments as Array<MoveStructId>,
   };
 }
 
-function decodeBigint(value: string): bigint {
-  return BigInt(value);
-}
-
-function decodeVector(type: string, value: any[]) {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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 (['address', 'bool', 'u8', 'u16', 'u32'].includes(innerType)) {
-    return value;
-  } else if (['u64', 'u128', 'u256'].includes(innerType)) {
-    return value.map((v: string) => BigInt(v));
-  } else {
-    // TODO: Figure out how to decode Vector of vector
-    return value;
-  }
-}
-
-function encodeVector(type: string, value: any[]) {
-  const regex = /vector<([^]+)>/;
-  const match = type.match(regex);
-  if (!match) {
-    // Should never happen
+  const innerType = match[1];
+  if(!innerType) {
     throw new Error(`Unsupported type: ${type}`);
   }
-  const innerType = match[1]!;
+
   if (innerType === 'u8') {
-    return (
-      HexString.fromUint8Array(
-        typeof value === 'string' ?
-          new TextEncoder().encode(value) :
-          value instanceof Uint8Array ?
-            value :
-            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;
+    if (typeof value === 'string' || value instanceof Uint8Array)
+      return value;
+    if (Array.isArray(value)) {
+      return arrayToHex(value)
+    }
+
+    throw new Error(`Invalid u8 value: ${value}`)
+
   } else if (['bool', 'u16', 'u32'].includes(innerType)) {
     return value;
   } else if (['u64', 'u128', 'u256'].includes(innerType)) {
@@ -148,3 +108,15 @@ function encodeVector(type: string, value: any[]) {
     return value;
   }
 }
+
+const arrayToHex = (array: (string | number)[]): string => {
+  let result = "0x";
+  array.forEach((item) => {
+    const n = ensureNumber(item);
+    if (n < 0 || n > 255)
+      throw new Error(`Invalid u8 value: ${n}`);
+    result += n.toString(16).padStart(2, '0');
+  })
+
+  return result;
+};

package/src/core/index.ts

@@ -1,3 +1,3 @@
-export { Client as MoveTsClient, createClient } from './Client.js';
+export { Client as MoveTsClient, createSurfClient } from './Client.js';
 export { createViewPayload } from './createViewPayload.js';
 export { createEntryPayload } from './createEntryPayload.js';

package/src/ensureTypes.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function assertType(val: any, types: string[] | string, message?: string) {
   if (!types?.includes(typeof val)) {
     throw new Error(

package/src/hooks/index.ts

@@ -1,5 +1,4 @@
 export {
-  submitTransactionOptions,
   useSubmitTransaction,
 } from './useSubmitTransaction.js';
 export { useWalletClient } from './useWalletClient.js';

package/src/hooks/useSubmitTransaction.ts

@@ -1,28 +1,16 @@
 import { useState, useRef } from 'react';
 import { useWallet } from '@aptos-labs/wallet-adapter-react';
-import { AptosClient, Types } from 'aptos';
 import type { EntryPayload } from '../types/index.js';
-
-export type submitTransactionOptions = {
-  nodeUrl: string;
-  onSuccess?: (result: Types.Transaction_UserTransaction) => void;
-  onFailed?: (error: Error) => void;
-  max_gas_amount?: string;
-};
-
-function isRawPayload(
-  payload: EntryPayload | Types.TransactionPayload_EntryFunctionPayload,
-): payload is EntryPayload {
-  return (<EntryPayload>payload).rawPayload !== undefined;
-}
+import { InputGenerateTransactionOptions } from '@aptos-labs/ts-sdk';
 
 // TODO: add test for this
 export const useSubmitTransaction = () => {
-  const { signAndSubmitTransaction } = useWallet();
+  const { connected, signAndSubmitTransaction, account } = useWallet();
 
   const [isIdle, setIsIdle] = useState(true);
   const [isLoading, setIsLoading] = useState(false);
-  const [data, setResult] = useState<Types.Transaction_UserTransaction>();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const [data, setResult] = useState<any>();
   const [error, setError] = useState<Error>();
   const idRef = useRef<number>(0);
 
@@ -35,10 +23,15 @@ export const useSubmitTransaction = () => {
   }
 
   async function submitTransaction(
-    payload: EntryPayload | Types.TransactionPayload_EntryFunctionPayload,
-    { nodeUrl, onSuccess, onFailed, max_gas_amount }: submitTransactionOptions,
-  ): Promise<void> {
+    payload: EntryPayload,
+    options?: InputGenerateTransactionOptions,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Promise<any> {
     // TODO: remove this
+    if (connected === false) {
+      throw new Error('Wallet is not connected');
+    }
+
     if (signAndSubmitTransaction === undefined) {
       return;
     }
@@ -50,71 +43,45 @@ export const useSubmitTransaction = () => {
     setIsLoading(true);
     setIsIdle(false);
 
-    // TODO: make it better. This way to determine the type is tricky.
-    const request = isRawPayload(payload) ? payload.rawPayload : payload;
-
+    let result
     try {
-      // TODO: use the BCS API instead
-      const { hash } = await signAndSubmitTransaction(
+      result = await 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();
-            }
-          }),
+          sender: account?.address ?? "",
+          data: {
+            ...payload,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            functionArguments: payload.functionArguments.map((arg: any) => {
+              if (Array.isArray(arg)) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                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();
+              }
+            }),
+          }
         },
-        { max_gas_amount },
+        options,
       );
 
-      const client = new AptosClient(nodeUrl);
-      const result = (await client.waitForTransactionWithResult(hash, {
-        checkSuccess: true,
-      })) as Types.Transaction_UserTransaction;
-
       // Only update the status if the request is not stale.
       if (id === idRef.current) {
-        try {
-          onSuccess?.(result);
-        } catch (e) {
-          // error from user's callback
-          console.error(e);
-        }
         setResult(result);
       }
     } catch (e) {
-      // Only update the status if the request is not stale.
-      if (id === idRef.current) {
-        const error =
-          e instanceof Error
-            ? e
-            : e
-            ? new Error(String(e))
-            : new Error('unknown error');
-
-        try {
-          onFailed?.(error);
-        } catch (e2) {
-          // error from user's callback
-          console.error(e2);
-        }
-
-        setError(error);
-      }
+      setError(error);
     } finally {
       // Only update the status if the request is not stale.
       if (id === idRef.current) {
         setIsLoading(false);
       }
     }
+
+    return result;
   }
 
   return { submitTransaction, reset, isLoading, isIdle, data, error };

package/src/hooks/useWalletClient.ts

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

package/src/index.ts

@@ -1,7 +1,7 @@
 export {
   createViewPayload,
   createEntryPayload,
-  createClient,
+  createSurfClient,
 } from './core/index.js';
 
 export type {

package/src/types/abi.ts

@@ -21,6 +21,7 @@ export interface ABIFunction {
 }
 
 export interface ABIFunctionGenericTypeParam {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constraints: readonly any[];
 }
 

package/src/types/client/abiClient.ts

@@ -2,8 +2,6 @@
  * The types for `client.useABI` API.
  */
 
-import type { AptosAccount } from 'aptos';
-import { TransactionResponse } from './client.js';
 import { ABIRoot } from '../abi.js';
 import { ABITable } from '../defaultABITable.js';
 import {
@@ -19,31 +17,29 @@ import {
   ExtractStructGenericArgsType,
   ExtractStructType,
 } from '../extractor/structExtractor.js';
+import { Account, AccountAddressInput, CommittedTransactionResponse } from '@aptos-labs/ts-sdk';
 
 export type ABIViewClient<T extends ABIRoot> = {
   [TFuncName in ViewFunctionName<T>]: (payload: {
-    type_arguments: ExtractGenericArgsType<T, TFuncName>;
-    arguments: ExtractArgsType<T, TFuncName>;
-    ledger_version?: string;
+    typeArguments: ExtractGenericArgsType<T, TFuncName>;
+    functionArguments: ExtractArgsType<T, TFuncName>;
+    ledgerVersion?: string;
   }) => Promise<ExtractReturnType<T, TFuncName>>;
 };
 
 export type ABIEntryClient<T extends ABIRoot> = {
   [TFuncName in EntryFunctionName<T>]: (payload: {
-    type_arguments: ExtractGenericArgsType<T, TFuncName>;
-    arguments: ExtractArgsTypeOmitSigner<T, TFuncName>;
-    account: AptosAccount;
+    typeArguments: ExtractGenericArgsType<T, TFuncName>;
+    functionArguments: ExtractArgsTypeOmitSigner<T, TFuncName>;
+    account: Account;
     isSimulation?: boolean;
-  }) => Promise<TransactionResponse>;
+  }) => Promise<CommittedTransactionResponse>;
 };
 
 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;
-  }>;
+    typeArguments: ExtractStructGenericArgsType<T, TStructName>;
+    account: AccountAddressInput;
+    ledgerVersion?: string;
+    }) => Promise<ExtractStructType<TABITable, T, TStructName>>;
 };