@thalalabs/surf 0.0.1

package/src/hooks/useSubmitTransaction.ts

@@ -0,0 +1,117 @@
+import { useState, useRef } from "react";
+import { useWallet } from "@aptos-labs/wallet-adapter-react";
+import { AptosClient, Types } from "aptos";
+import { EntryPayload } from "../types";
+
+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;
+}
+
+export const useSubmitTransaction = () => {
+    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);
+
+    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;
+
+        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;
+
+        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;
+
+            // 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);
+            }
+        } finally {
+            // Only update the status if the request is not stale.
+            if (id === idRef.current) {
+                setIsLoading(false);
+            }
+        }
+    }
+
+    return { submitTransaction, reset, isLoading, isIdle, data, error };
+};

package/src/hooks/useWalletClient.ts

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

package/src/index.ts

@@ -0,0 +1,10 @@
+export {
+    createViewPayload,
+    createEntryPayload,
+    createClient
+} from "./core";
+
+export {
+    EntryPayload,
+    ViewPayload,
+} from "./types";

package/src/types/abi.ts

@@ -0,0 +1,35 @@
+
+export interface ABIRoot {
+    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[];
+}
+
+export interface ABIFunctionGenericTypeParam {
+    constraints: readonly any[];
+}
+
+export interface ABIStruct {
+    name: string;
+    is_native: boolean;
+    abilities: readonly string[];
+    generic_type_params: readonly ABIFunctionGenericTypeParam[];
+    fields: readonly ABIStructField[];
+}
+
+export interface ABIStructField {
+    name: string;
+    type: string;
+}

package/src/types/abiClient.ts

@@ -0,0 +1,19 @@
+import { AptosAccount } from "aptos";
+import { ABIRoot } from "./abi";
+import { EntryFunctionName, ExtractGenericParamsType, ExtractParamsType, ExtractParamsTypeOmitSigner, ExtractReturnType, TransactionResponse, ViewFunctionName } from "./common";
+
+export type ABIViewClient<T extends ABIRoot> = {
+    [TFuncName in ViewFunctionName<T>]: (payload: {
+        type_arguments: ExtractGenericParamsType<T, TFuncName>
+        arguments: ExtractParamsType<T, TFuncName>,
+    }) => Promise<ExtractReturnType<T, TFuncName>>
+};
+
+export type ABIEntryClient<T extends ABIRoot> = {
+    [TFuncName in EntryFunctionName<T>]: (payload: {
+        type_arguments: ExtractGenericParamsType<T, TFuncName>,
+        arguments: ExtractParamsTypeOmitSigner<T, TFuncName>,
+        account: AptosAccount,
+        isSimulation?: boolean
+    }) => Promise<TransactionResponse>
+};

package/src/types/client.ts

@@ -0,0 +1,32 @@
+import { AptosAccount, TxnBuilderTypes } from "aptos";
+
+export type EntryOptions = {
+    account: AptosAccount,
+}
+
+export type ViewOptions = {
+    ledger_version?: string;
+}
+
+export type EntryPayload = {
+    rawPayload: {
+        function: string;
+        type_arguments: string[];
+        arguments: any[];
+    },
+    entryRequest: TxnBuilderTypes.EntryFunction,
+    // readonly abi: any,
+};
+
+//@ts-ignore TODO: remove this ignore
+export type ViewPayload<TReturn> = {
+    viewRequest: {
+        function: string;
+        type_arguments: string[];
+        arguments: any[];
+    };
+    decoders: (((value: any) => any) | null)[],
+    // readonly abi: any,
+    // readonly return: TReturn,
+};
+

package/src/types/common.ts

@@ -0,0 +1,157 @@
+import { ABIRoot } from "./abi";
+
+// TODO: rename this variable, not only primitive, but also struct and vector
+export type Primitive =
+    'bool' | 'u8' | 'u16' | 'u32' |
+    'u64' | 'u128' | 'u256' | 'address' |
+    '0x1::string::String';
+
+type Vector = `vector<${Primitive}>`;
+type VectorOfVector = `vector<vector<${Primitive}>>`;
+
+// TODO: support struct, vector<struct>, and vector<vector<vector>>
+export type AllTypes = Primitive | Vector | VectorOfVector;
+type ConvertPrimitiveArgsType<T extends Primitive> =
+    T extends 'bool' ? boolean :
+    T extends 'u8' ? number :
+    T extends 'u16' ? number :
+    T extends 'u32' ? number :
+    T extends 'u64' ? AnyNumber :
+    T extends 'u128' ? AnyNumber :
+    T extends 'u256' ? AnyNumber :
+    T extends 'address' ? `0x${string}` :
+    T extends '0x1::string::String' ? string :
+    never;
+
+type ConvertVectorArgsType<TInner> = TInner extends Primitive ? ConvertPrimitiveArgsType<TInner>[] :
+    (
+        TInner extends `vector<${infer TInnerInner}>` ? (
+            TInnerInner extends Primitive ? ConvertPrimitiveArgsType<TInnerInner>[][] :
+            any[][]) : (
+            object[]
+        )
+    );
+
+export type ConvertArgsType<T extends AllTypes> =
+    T extends Primitive ? ConvertPrimitiveArgsType<T> :
+    T extends `vector<${infer TInner}>` ? ConvertVectorArgsType<TInner> :
+    Struct<T>;
+
+//@ts-ignore TODO: remove this ignore
+type Struct<T extends string> = object;
+
+type AnyNumber = number | bigint | string;
+
+export type ConvertPrimitiveReturnType<T extends Primitive> =
+    T extends 'bool' ? boolean :
+    T extends 'u8' ? number :
+    T extends 'u16' ? number :
+    T extends 'u32' ? number :
+    T extends 'u64' ? bigint :
+    T extends 'u128' ? bigint :
+    T extends 'u256' ? bigint :
+    T extends 'address' ? `0x${string}` :
+    T extends '0x1::string::String' ? string :
+    never;
+
+type ConvertVectorReturnType<TInner> = TInner extends Primitive ? ConvertPrimitiveReturnType<TInner>[] :
+    (
+        TInner extends `vector<${infer TInnerInner}>` ? (
+            TInnerInner extends Primitive ? ConvertPrimitiveReturnType<TInnerInner>[][] :
+            any[][]) : (
+            object[]
+        )
+    );
+
+export type ConvertReturnType<T extends AllTypes> =
+    T extends Primitive ? ConvertPrimitiveReturnType<T> :
+    T extends `vector<${infer TInner}>` ? ConvertVectorReturnType<TInner> :
+    Struct<T>;
+
+type Functions<T extends ABIRoot> = T['exposed_functions'];
+type MoveFunction<T extends ABIRoot> = Functions<T>[number];
+type FunctionName<T extends ABIRoot> = MoveFunction<T>['name'];
+
+export type ExtractFunction<T extends ABIRoot, TFuncName extends FunctionName<T>> =
+    Extract<MoveFunction<T>, { name: TFuncName }>;
+
+export type MoveViewFunction<T extends ABIRoot> = Extract<Functions<T>[number], { is_view: true }>;
+export type ViewFunctionName<T extends ABIRoot> = MoveViewFunction<T>['name'];
+export type MoveEntryFunction<T extends ABIRoot> = Extract<Functions<T>[number], { is_entry: true }>;
+export type EntryFunctionName<T extends ABIRoot> = MoveEntryFunction<T>['name'];
+
+// TODO: Figure out how to return the correct array type
+type ConvertParams<T extends readonly string[]> = {
+    [P in keyof T]: T[P] extends AllTypes ? ConvertArgsType<T[P]> : Struct<T[P]>;
+};
+
+export type ConvertEntryParams<T extends readonly string[]> = ConvertParams<OmitSigner<T>>;
+
+// TODO: Figure out how to return the correct array type
+export type ConvertReturns<T extends readonly string[]> = {
+    [P in keyof T]: T[P] extends AllTypes ? ConvertReturnType<T[P]> : Struct<T[P]>;
+};
+
+export type ExtractReturnType<
+    T extends ABIRoot,
+    TFuncName extends FunctionName<T>> =
+    ConvertReturns<ExtractRawReturnType<T, TFuncName>>;
+
+export type ExtractRawReturnType<
+    T extends ABIRoot,
+    TFuncName extends FunctionName<T>> =
+    ExtractFunction<T, TFuncName>['return'];
+
+export type ExtractParamsType<
+    T extends ABIRoot,
+    TFuncName extends FunctionName<T>> =
+    ConvertParams<ExtractRawParamsType<T, TFuncName>>;
+
+export type ExtractParamsTypeOmitSigner<
+    T extends ABIRoot,
+    TFuncName extends FunctionName<T>> =
+    ConvertParams<OmitSigner<ExtractRawParamsType<T, TFuncName>>>;
+
+export type ExtractRawParamsType<
+    T extends ABIRoot,
+    TFuncName extends FunctionName<T>> =
+    ExtractFunction<T, TFuncName>['params'];
+
+export type ExtractGenericParamsType<
+    T extends ABIRoot,
+    TFuncName extends FunctionName<T>> =
+    ConvertTypeParams<ExtractRawGenericParamsType<T, TFuncName>>;
+
+export type ExtractRawGenericParamsType<
+    T extends ABIRoot,
+    TFuncName extends FunctionName<T>> =
+    ExtractFunction<T, TFuncName>['generic_type_params'];
+
+// TODO: Figure out how to return the correct array type
+export type ConvertTypeParams<T extends readonly any[]> = {
+    [P in keyof T]: string;
+};
+
+export type ViewRequestPayload<T extends ABIRoot, TFuncName extends ViewFunctionName<T>> = {
+    function: TFuncName,
+    arguments: ExtractParamsType<T, TFuncName>,
+    type_arguments: ExtractGenericParamsType<T, TFuncName>
+}
+
+// Remove all `signer` and `&signer` from argument list because the Move VM injects those arguments. Clients do not
+// need to care about those args. `signer` and `&signer` are required be in the front of the argument list.
+type OmitSigner<T extends readonly string[]> = T extends readonly ['&signer' | 'signer', ...infer Rest]
+    ? Rest
+    : T;
+
+export type EntryRequestPayload<
+    T extends ABIRoot,
+    TFuncName extends EntryFunctionName<T>> = {
+        function: TFuncName,
+        arguments: ExtractParamsTypeOmitSigner<T, TFuncName>,
+        type_arguments: ExtractGenericParamsType<T, TFuncName>
+    }
+
+export type TransactionResponse = {
+    hash: string;
+}

package/src/types/index.ts

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

package/src/types/walletClient.ts

@@ -0,0 +1,10 @@
+import { ABIRoot } from "./abi";
+import { EntryFunctionName, ExtractGenericParamsType, ExtractParamsTypeOmitSigner, TransactionResponse } from "./common";
+
+export type ABIWalletClient<T extends ABIRoot> = {
+    [TFuncName in EntryFunctionName<T>]:
+    (payload: {
+        type_arguments: ExtractGenericParamsType<T, TFuncName>,
+        arguments: ExtractParamsTypeOmitSigner<T, TFuncName>,
+    }) => Promise<TransactionResponse>
+};