@thalalabs/surf 0.0.11 → 0.0.12

package/src/core/createViewPayload.ts

@@ -1,13 +1,18 @@
-import { HexString } from "aptos";
-import type { ABIRoot, ViewPayload } from "../types/index.js";
-import type { ExtractReturnType, ViewFunctionName, ViewRequestPayload } from "../types/common.js";
-import { ensureNumber } from "../ensureTypes.js";
+import { HexString } from 'aptos';
+import {
+  ABIRoot,
+  ExtractReturnType,
+  ViewFunctionName,
+  ViewPayload,
+  ViewRequestPayload,
+} from '../types/index.js';
+import { ensureNumber } from '../ensureTypes.js';
 
 // TODO: support vector<u8> input with Uint8Array
 // TODO: support vector<u8> input with string
 /**
  * Create a payload for calling a view function.
- * 
+ *
  * @param abi The ABI JSON contains the view function. For type inference and encoding/decoding purpose.
  * @param payload.function The function name.
  * @param payload.arguments The input arguments for function.
@@ -22,113 +27,120 @@ import { ensureNumber } from "../ensureTypes.js";
  * const [balance] = await client.view(viewPayload);
  */
 export function createViewPayload<
-    T extends ABIRoot,
-    TFuncName extends ViewFunctionName<T>
+  T extends ABIRoot,
+  TFuncName extends ViewFunctionName<T>,
 >(
-    abi: T,
-    payload: ViewRequestPayload<T, TFuncName>
-):
-    ViewPayload<ExtractReturnType<T, TFuncName>> {
-    const fnAbi = abi.exposed_functions.filter(f => f.name === payload.function)[0];
-    const type_arguments: string[] = payload.type_arguments as any[];
-    const val_arguments: any[] = payload.arguments as any[];
+  abi: T,
+  payload: ViewRequestPayload<T, TFuncName>,
+): ViewPayload<ExtractReturnType<T, TFuncName>> {
+  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;
 
-    // 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`);
-    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`);
+  // 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`,
+    );
+  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`,
+    );
 
-    // TODO: do serialization here
-    const args = fnAbi.params.map((type, i) => {
-        const arg = payload.arguments[i]!;
-        if (['u8', 'u16', 'u32'].includes(type)) {
-            return ensureNumber(arg as number);
-        }
-        else if (['u64', 'u128', 'u256'].includes(type)) {
-            return arg.toString();
-        }
-        else if (type.includes("vector")) {
-            return encodeVector(type, arg as any[]);
-        }
-        else { // string or address
-            return arg;
-        }
-    });
+  // TODO: do serialization here
+  const args = fnAbi.params.map((type, i) => {
+    const arg = payload.arguments[i] as unknown;
+    if (['u8', 'u16', 'u32'].includes(type)) {
+      return ensureNumber(arg as number);
+    } else if (['u64', 'u128', 'u256'].includes(type)) {
+      if (!arg?.toString) {
+        throw new Error(`Expecting a bigint, but got ${arg}`);
+      }
+      return arg.toString();
+    } else if (type.includes('vector')) {
+      return encodeVector(type, arg as any[]);
+    } else {
+      // string or address
+      return arg;
+    }
+  });
 
-    // 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;
-        }
-    });
+  // 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,
-    };
+  return {
+    viewRequest: {
+      function: `${abi.address}::${abi.name}::${payload.function}`,
+      arguments: args,
+      type_arguments: payload.type_arguments as string[],
+    },
+    decoders,
+  };
 }
 
 function decodeBigint(value: string): bigint {
-    return BigInt(value);
+  return BigInt(value);
 }
 
 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]!;
+  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;
-    }
+  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
-        throw new Error(`Unsupported type: ${type}`);
-    }
-    const innerType = match[1]!;
-    if (innerType === "u8") {
-        return (
-            HexString.fromUint8Array(
-                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;
-    } else if (["bool", "u16", "u32"].includes(innerType)) {
-        return value;
-    } else if (["u64", "u128", "u256"].includes(innerType)) {
-        return value.map((v: bigint) => v.toString());
-    } else { // string or address
-        // TODO: encode for Vector of vector
-        return value;
-    }
-}
+  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(
+          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;
+  } else if (['bool', 'u16', 'u32'].includes(innerType)) {
+    return value;
+  } else if (['u64', 'u128', 'u256'].includes(innerType)) {
+    return value.map((v: bigint) => v.toString());
+  } else {
+    // string or address
+    // TODO: encode for Vector of vector
+    return value;
+  }
+}

package/src/core/index.ts

@@ -1,4 +1,4 @@
-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";
+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,5 @@
-export { submitTransactionOptions, useSubmitTransaction } from "./useSubmitTransaction.js";
-export { useWalletClient } from "./useWalletClient.js";
+export {
+  submitTransactionOptions,
+  useSubmitTransaction,
+} from './useSubmitTransaction.js';
+export { useWalletClient } from './useWalletClient.js';

package/src/hooks/useSubmitTransaction.ts

@@ -1,118 +1,121 @@
-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";
+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,
-}
+  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;
+function isRawPayload(
+  payload: EntryPayload | Types.TransactionPayload_EntryFunctionPayload,
+): payload is EntryPayload {
+  return (<EntryPayload>payload).rawPayload !== undefined;
 }
 
 // TODO: add test for this
 export const useSubmitTransaction = () => {
-    const { signAndSubmitTransaction } = useWallet();
+  const { signAndSubmitTransaction } = useWallet();
 
-    const [isIdle, setIsIdle] = useState(true);
-    const [isLoading, setIsLoading] = useState(false);
-    const [data, setResult] = useState<Types.Transaction_UserTransaction>();
-    const [error, setError] = useState<Error>();
-    const idRef = useRef<number>(0);
+  const [isIdle, setIsIdle] = useState(true);
+  const [isLoading, setIsLoading] = useState(false);
+  const [data, setResult] = useState<Types.Transaction_UserTransaction>();
+  const [error, setError] = useState<Error>();
+  const idRef = useRef<number>(0);
 
-    function reset() {
-        setIsIdle(true);
-        setIsLoading(false);
-        setResult(undefined);
-        setError(undefined);
-        idRef.current = idRef.current + 1;
-    }
+  function reset() {
+    setIsIdle(true);
+    setIsLoading(false);
+    setResult(undefined);
+    setError(undefined);
+    idRef.current = idRef.current + 1;
+  }
 
-    async function submitTransaction(
-        payload: EntryPayload | Types.TransactionPayload_EntryFunctionPayload,
-        {
-            nodeUrl,
-            onSuccess,
-            onFailed,
-            max_gas_amount
-        }: submitTransactionOptions
-    ): Promise<void> {
-        // TODO: remove this
-        if (signAndSubmitTransaction === undefined) {
-            return;
-        }
-        const id = idRef.current;
+  async function submitTransaction(
+    payload: EntryPayload | Types.TransactionPayload_EntryFunctionPayload,
+    { nodeUrl, onSuccess, onFailed, max_gas_amount }: submitTransactionOptions,
+  ): Promise<void> {
+    // TODO: remove this
+    if (signAndSubmitTransaction === undefined) {
+      return;
+    }
+    const id = idRef.current;
 
-        if (!isIdle) {
-            throw new Error("Transaction is already in progress");
-        }
-        setIsLoading(true);
-        setIsIdle(false);
+    if (!isIdle) {
+      throw new Error('Transaction is already in progress');
+    }
+    setIsLoading(true);
+    setIsIdle(false);
 
-        // TODO: make it better. This way to determine the type is tricky.
-        const request = isRawPayload(payload) ? payload.rawPayload : payload;
+    // TODO: make it better. This way to determine the type is tricky.
+    const request = isRawPayload(payload) ? payload.rawPayload : payload;
 
-        try {
-            // TODO: use the BCS API instead
-            const { hash } = 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();
-                    }
-                }),
-            }, { max_gas_amount });
+    try {
+      // TODO: use the BCS API instead
+      const { hash } = 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();
+            }
+          }),
+        },
+        { max_gas_amount },
+      );
 
-            const client = new AptosClient(nodeUrl);
-            const result = (await client.waitForTransactionWithResult(hash, {
-                checkSuccess: true,
-            })) as Types.Transaction_UserTransaction;
+      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);
-            }
+      // Only update the status if the request is not stale.
+      if (id === idRef.current) {
+        try {
+          onSuccess?.(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);
-                }
+          // 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');
 
-                setError(error);
-            }
-        } finally {
-            // Only update the status if the request is not stale.
-            if (id === idRef.current) {
-                setIsLoading(false);
-            }
+        try {
+          onFailed?.(error);
+        } catch (e2) {
+          // error from user's callback
+          console.error(e2);
         }
+
+        setError(error);
+      }
+    } finally {
+      // Only update the status if the request is not stale.
+      if (id === idRef.current) {
+        setIsLoading(false);
+      }
     }
+  }
 
-    return { submitTransaction, reset, isLoading, isIdle, data, error };
-};
+  return { submitTransaction, reset, isLoading, isIdle, data, error };
+};

package/src/hooks/useWalletClient.ts

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

package/src/types/abi.ts

@@ -1,35 +1,38 @@
+/**
+ * The ABI JSON related types.
+ */
 
 export interface ABIRoot {
-    address: string;
-    name: string;
-    friends: readonly string[];
-    exposed_functions: readonly ABIFunction[];
-    structs: readonly ABIStruct[];
+  address: string;
+  name: string;
+  friends: readonly string[];
+  exposed_functions: readonly ABIFunction[];
+  structs: readonly ABIStruct[];
 }
 
 export interface ABIFunction {
-    name: string;
-    visibility: "friend" | "public";
-    is_entry: boolean;
-    is_view: boolean;
-    generic_type_params: readonly ABIFunctionGenericTypeParam[];
-    params: readonly string[];
-    return: readonly string[];
+  name: string;
+  visibility: 'friend' | 'public';
+  is_entry: boolean;
+  is_view: boolean;
+  generic_type_params: readonly ABIFunctionGenericTypeParam[];
+  params: readonly string[];
+  return: readonly string[];
 }
 
 export interface ABIFunctionGenericTypeParam {
-    constraints: readonly any[];
+  constraints: readonly any[];
 }
 
 export interface ABIStruct {
-    name: string;
-    is_native: boolean;
-    abilities: readonly string[];
-    generic_type_params: readonly ABIFunctionGenericTypeParam[];
-    fields: readonly ABIStructField[];
+  name: string;
+  is_native: boolean;
+  abilities: readonly string[];
+  generic_type_params: readonly ABIFunctionGenericTypeParam[];
+  fields: readonly ABIStructField[];
 }
 
 export interface ABIStructField {
-    name: string;
-    type: string;
-}
+  name: string;
+  type: string;
+}

package/src/types/client/abiClient.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 {
+  EntryFunctionName,
+  ExtractArgsType,
+  ExtractArgsTypeOmitSigner,
+  ExtractGenericArgsType,
+  ExtractReturnType,
+  ViewFunctionName,
+} from '../extractor/functionExtractor.js';
+import {
+  ResourceStructName,
+  ExtractStructGenericArgsType,
+  ExtractStructType,
+} from '../extractor/structExtractor.js';
+
+export type ABIViewClient<T extends ABIRoot> = {
+  [TFuncName in ViewFunctionName<T>]: (payload: {
+    type_arguments: ExtractGenericArgsType<T, TFuncName>;
+    arguments: ExtractArgsType<T, TFuncName>;
+  }) => 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;
+    isSimulation?: boolean;
+  }) => Promise<TransactionResponse>;
+};
+
+export type ABIResourceClient<TABITable extends ABITable, T extends ABIRoot> = {
+  [TStructName in ResourceStructName<T>]: (payload: {
+    type_arguments: ExtractStructGenericArgsType<T, TStructName>;
+    account: `0x${string}`;
+  }) => Promise<{
+    data: ExtractStructType<TABITable, T, TStructName>;
+    type: string;
+  }>;
+};