@thalalabs/surf 0.0.5 → 0.0.7

package/src/abi/table.ts

@@ -0,0 +1,295 @@
+export const TABLE_ABI = {
+    "address": "0x1",
+    "name": "table",
+    "friends": [
+        "0x1::table_with_length"
+    ],
+    "exposed_functions": [
+        {
+            "name": "add",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": []
+                }
+            ],
+            "params": [
+                "&mut 0x1::table::Table<T0, T1>",
+                "T0",
+                "T1"
+            ],
+            "return": []
+        },
+        {
+            "name": "borrow",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": []
+                }
+            ],
+            "params": [
+                "&0x1::table::Table<T0, T1>",
+                "T0"
+            ],
+            "return": [
+                "&T1"
+            ]
+        },
+        {
+            "name": "borrow_mut",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": []
+                }
+            ],
+            "params": [
+                "&mut 0x1::table::Table<T0, T1>",
+                "T0"
+            ],
+            "return": [
+                "&mut T1"
+            ]
+        },
+        {
+            "name": "borrow_mut_with_default",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": [
+                        "drop"
+                    ]
+                }
+            ],
+            "params": [
+                "&mut 0x1::table::Table<T0, T1>",
+                "T0",
+                "T1"
+            ],
+            "return": [
+                "&mut T1"
+            ]
+        },
+        {
+            "name": "borrow_with_default",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": []
+                }
+            ],
+            "params": [
+                "&0x1::table::Table<T0, T1>",
+                "T0",
+                "&T1"
+            ],
+            "return": [
+                "&T1"
+            ]
+        },
+        {
+            "name": "contains",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": []
+                }
+            ],
+            "params": [
+                "&0x1::table::Table<T0, T1>",
+                "T0"
+            ],
+            "return": [
+                "bool"
+            ]
+        },
+        {
+            "name": "destroy",
+            "visibility": "friend",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": []
+                }
+            ],
+            "params": [
+                "0x1::table::Table<T0, T1>"
+            ],
+            "return": []
+        },
+        {
+            "name": "new",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": [
+                        "store"
+                    ]
+                }
+            ],
+            "params": [],
+            "return": [
+                "0x1::table::Table<T0, T1>"
+            ]
+        },
+        {
+            "name": "remove",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": []
+                }
+            ],
+            "params": [
+                "&mut 0x1::table::Table<T0, T1>",
+                "T0"
+            ],
+            "return": [
+                "T1"
+            ]
+        },
+        {
+            "name": "upsert",
+            "visibility": "public",
+            "is_entry": false,
+            "is_view": false,
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": [
+                        "drop"
+                    ]
+                }
+            ],
+            "params": [
+                "&mut 0x1::table::Table<T0, T1>",
+                "T0",
+                "T1"
+            ],
+            "return": []
+        }
+    ],
+    "structs": [
+        {
+            "name": "Box",
+            "is_native": false,
+            "abilities": [
+                "drop",
+                "store",
+                "key"
+            ],
+            "generic_type_params": [
+                {
+                    "constraints": []
+                }
+            ],
+            "fields": [
+                {
+                    "name": "val",
+                    "type": "T0"
+                }
+            ]
+        },
+        {
+            "name": "Table",
+            "is_native": false,
+            "abilities": [
+                "store"
+            ],
+            "generic_type_params": [
+                {
+                    "constraints": [
+                        "copy",
+                        "drop"
+                    ]
+                },
+                {
+                    "constraints": []
+                }
+            ],
+            "fields": [
+                {
+                    "name": "handle",
+                    "type": "address"
+                }
+            ]
+        }
+    ]
+} as const;

package/src/core/Client.ts

@@ -3,6 +3,7 @@ import { createViewPayload } from "./createViewPayload.js";
 import { createEntryPayload } from "./createEntryPayload.js";
 import type { ABIEntryClient, ABIViewClient, ABIRoot, EntryOptions, EntryPayload, ViewOptions, ViewPayload } from "../types/index.js";
 import type { TransactionResponse } from "../types/common.js";
+import { ABIResourceClient } from "../types/abiClient.js";
 
 export function createClient(options: { nodeUrl: string }): Client {
     return new Client(
@@ -27,7 +28,7 @@ export class Client {
         );
 
         // Decode the return value
-        // TODO: for vectors, struct
+        // TODO: for struct
         return result.map((value, i) =>
             payload.decoders[i] ?
                 payload.decoders[i]!(value) :
@@ -101,7 +102,23 @@ export class Client {
                             this.submitTransaction(payload, { account: args[0].account });
                     };
                 }
-            })
+            }),
+            resource: new Proxy({} as ABIResourceClient<T>, {
+                get: (_, prop) => {
+                    let structName = prop.toString();
+                    return (...args) => {
+                        if(args[0].type_arguments.length !== 0) {
+                            structName += `<${args[0].type_arguments.join(",")}>`;
+                        }
+                        return this.client.getAccountResource(
+                            args[0].account,
+                            `${abi.address}::${abi.name}::${structName}`,
+                        );
+
+                        // TODO: decode the u64, u128, u256 to bigint
+                    };
+                }
+            }),
         };
     }
 

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

@@ -0,0 +1,39 @@
+/**
+ * These test cases depends on network, it call the real contract.
+ */
+
+import { COIN_ABI } from '../../abi/coin';
+import { createClient } from '../Client';
+
+describe('get account resource', () => {
+  const client = createClient({
+    nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',
+  });
+
+  // Act before assertions
+  beforeAll(async () => {});
+
+  // Teardown (cleanup) after assertions
+  afterAll(() => {});
+
+  it('get CoinStore', async () => {
+    const result = await client.useABI(COIN_ABI).resource.CoinStore({
+      type_arguments: ['0x1::aptos_coin::AptosCoin'],
+      account: '0x1',
+    });
+
+    expect(result.data.frozen).toBeFalsy();
+    expect(result.data.coin).toBeDefined();
+    expect(result.data.deposit_events).toBeDefined();
+    expect(result.data.withdraw_events).toBeDefined();
+
+    // can inference nested struct
+    expect(result.data.deposit_events.guid.id.creation_num.startsWith).toBeDefined();
+
+    // @ts-expect-error field not exist
+    expect(result.data.deposit_events.guid.id.abc).toBeUndefined();
+
+    // @ts-expect-error field not exist
+    expect(result.abc).toBeUndefined();
+  }, 60000);
+});

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

@@ -1,7 +1,7 @@
 import { COIN_ABI } from "../../abi/coin";
 import { createEntryPayload } from "../createEntryPayload";
 
-// TODO: add struct, vector of vector, vector
+// TODO: add vector of vector, vector
 describe('createEntryPayload', () => {
     // Act before assertions
     beforeAll(async () => { });

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

@@ -47,7 +47,7 @@ describe('call view functions', () => {
     `);
     }, 60000);
 
-    it('struct', async () => {
+    it('return struct', async () => {
         const viewPayload = createViewPayload(TIERED_ORACLE_ABI, {
             function: 'get_last_price',
             arguments: [],

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

@@ -5,7 +5,7 @@
 import { createClient } from '../Client';
 import { createViewPayload } from '../createViewPayload';
 
-// TODO: add vector<address>, vector<struct>
+// TODO: add vector<address>, vector<vector>
 describe('call view functions for vector type', () => {
   const client = createClient({
     nodeUrl: 'https://fullnode.testnet.aptoslabs.com/v1',

package/src/core/createEntryPayload.ts

@@ -92,8 +92,6 @@ function argToBCS(type: string, arg: any, serializer: BCS.Serializer) {
         return;
     }
 
-    // TODO: it's struct
-
     switch (type) { // It's primitive
         case 'bool':
             serializer.serializeBool(ensureBoolean(arg));

package/src/core/createViewPayload.ts

@@ -34,7 +34,7 @@ export function createViewPayload<
         else if (type.includes("vector")) {
             return encodeVector(type, arg as any[]);
         }
-        else {
+        else { // string or address
             return arg;
         }
     });
@@ -81,8 +81,7 @@ function decodeVector(type: string, value: any[]) {
     else if (["u64", "u128", "u256"].includes(innerType)) {
         return value.map((v: string) => BigInt(v));
     } else {
-        // 1. TODO: Figure out how to decode Struct type
-        // 2. TODO: Figure out how to decode Vector of vector, vector of struct
+        // TODO: Figure out how to decode Vector of vector
         return value;
     }
 }
@@ -112,10 +111,8 @@ function encodeVector(type: string, value: any[]) {
         return value;
     } else if (["u64", "u128", "u256"].includes(innerType)) {
         return value.map((v: bigint) => v.toString());
-    } else {
-        // 1. Address type no need to encode
-        // 2. TODO: Figure out how to encode Struct type
-        // 3. TODO: Figure out how to encode Vector of vector, vector of struct
+    } else { // string or address
+        // TODO: encode for Vector of vector
         return value;
     }
 }

package/src/hooks/useSubmitTransaction.ts

@@ -14,6 +14,7 @@ function isRawPayload(payload: EntryPayload | Types.TransactionPayload_EntryFunc
     return (<EntryPayload>payload).rawPayload !== undefined;
 }
 
+// TODO: add test for this
 export const useSubmitTransaction = () => {
     const { signAndSubmitTransaction } = useWallet();
 

package/src/types/abiClient.ts

@@ -9,6 +9,7 @@ import type {
     TransactionResponse,
     ViewFunctionName
 } from "./common.js";
+import { ExtractStructGenericParamsType, ExtractStructType, ResourceStructName } from "./struct.js";
 
 export type ABIViewClient<T extends ABIRoot> = {
     [TFuncName in ViewFunctionName<T>]: (payload: {
@@ -24,4 +25,14 @@ export type ABIEntryClient<T extends ABIRoot> = {
         account: AptosAccount,
         isSimulation?: boolean
     }) => Promise<TransactionResponse>
-};
+};
+
+export type ABIResourceClient<T extends ABIRoot> = {
+    [TStructName in ResourceStructName<T>]: (payload: {
+        type_arguments: ExtractStructGenericParamsType<T, TStructName>,
+        account: `0x${string}`,
+    }) => Promise<{
+        data: ExtractStructType<T, TStructName>,
+        type: string
+    }>
+};

package/src/types/common.ts

@@ -9,7 +9,7 @@ export type Primitive =
 type Vector = `vector<${Primitive}>`;
 type VectorOfVector = `vector<vector<${Primitive}>>`;
 
-// TODO: support struct, vector<struct>, and vector<vector<vector>>
+// TODO: support vector<vector<vector>>
 export type AllTypes = Primitive | Vector | VectorOfVector;
 type ConvertPrimitiveArgsType<T extends Primitive> =
     T extends 'bool' ? boolean :
@@ -80,6 +80,7 @@ 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]>;

package/src/types/globalABI.ts

@@ -0,0 +1,13 @@
+import type { COIN_ABI } from "../abi/coin.js";
+import type { EVENT_ABI } from "../abi/event.js";
+import { FIXED_POINT64_ABI } from "../abi/fixed_point64.js";
+import type { GUID_ABI } from "../abi/guid.js";
+import { TABLE_ABI } from "../abi/table.js";
+
+export type GlobalABITable = {
+    '0x1::coin': typeof COIN_ABI,
+    '0x1::event': typeof EVENT_ABI,
+    '0x1::guid': typeof GUID_ABI,
+    '0x1::table': typeof TABLE_ABI,
+    '0x4dcae85fc5559071906cd5c76b7420fcbb4b0a92f00ab40ffc394aadbbff5ee9::fixed_point64': typeof FIXED_POINT64_ABI,
+};

package/src/types/struct.ts

@@ -0,0 +1,78 @@
+import { ABIRoot } from "./abi.js";
+import { AllTypes, ConvertTypeParams, Primitive } from "./common.js";
+import { GlobalABITable } from "./globalABI.js";
+
+type Struct<_T extends string> = object;
+
+export type ConvertPrimitiveStructField<T extends Primitive> =
+    T extends 'bool' ? boolean :
+    T extends 'u8' ? number :
+    T extends 'u16' ? number :
+    T extends 'u32' ? number :
+    T extends 'u64' ? string :
+    T extends 'u128' ? string :
+    T extends 'u256' ? string :
+    T extends 'address' ? `0x${string}` :
+    T extends '0x1::string::String' ? string :
+    never;
+
+type ConvertVectorStructField<TInner> = TInner extends Primitive ? ConvertPrimitiveStructField<TInner>[] :
+    (
+        TInner extends `vector<${infer TInnerInner}>` ? (
+            TInnerInner extends Primitive ? ConvertPrimitiveStructField<TInnerInner>[][] :
+            any[][]) : (
+            object[]
+        )
+    );
+
+type MoveStruct<T extends ABIRoot> = T['structs'][number];
+
+export type ResourceStructName<T extends ABIRoot> = MoveStruct<T>['name'];
+
+type ExtractStructFieldsName<
+    T extends ABIRoot,
+    TStructName extends ResourceStructName<T>> = ExtractStruct<T, TStructName>['fields'][number]['name'];
+
+type ExtractStruct<T extends ABIRoot, TResourceName extends ResourceStructName<T>> =
+    Extract<MoveStruct<T>, { name: TResourceName }>;
+
+type ExtractStructFieldType<
+    T extends ABIRoot,
+    TStructName extends ResourceStructName<T>,
+    TFieldName extends string> = Extract<ExtractStruct<T, TStructName>['fields'][number], { name: TFieldName }>['type'];
+
+export type ConvertStructField<T extends AllTypes> =
+    T extends Primitive ? ConvertPrimitiveStructField<T> :
+    T extends `vector<${infer TInner}>` ? ConvertVectorStructField<TInner> :
+    Struct<T>;
+
+export type ExtractStructType<
+    T extends ABIRoot,
+    TStructName extends ResourceStructName<T>> = {
+        [TField in ExtractStructFieldsName<T, TStructName>]:
+        ExtractStructFieldType<T, TStructName, TField> extends AllTypes ?
+        // it's a non-struct type
+        ConvertStructField<ExtractStructFieldType<T, TStructName, TField>> :
+        // it's a struct type
+        ExtractStructTypeGlobal<ExtractStructFieldType<T, TStructName, TField>>;
+    };
+
+export type ExtractStructRawGenericParamsType<
+    T extends ABIRoot,
+    TStructName extends ResourceStructName<T>> =
+    ExtractStruct<T, TStructName>['generic_type_params'];
+
+export type ExtractStructGenericParamsType<
+    T extends ABIRoot,
+    TStructName extends ResourceStructName<T>> =
+    ConvertTypeParams<ExtractStructRawGenericParamsType<T, TStructName>>;
+
+type ExtractStructTypeGlobal<TAddress extends string> =
+    TAddress extends `${infer TAccountAddress}::${infer TModuleName}::${infer TStructName}${'' | `<${infer _TInnerType}>`}`
+    ? `${TAccountAddress}::${TModuleName}` extends keyof GlobalABITable ?
+    OmitInner<TStructName> extends ResourceStructName<GlobalABITable[`${TAccountAddress}::${TModuleName}`]> ?
+    ExtractStructType<GlobalABITable[`${TAccountAddress}::${TModuleName}`], OmitInner<TStructName>>
+    // Unknown struct, use the default struct type
+    : Struct<TAddress> : Struct<TAddress> : Struct<TAddress>;
+
+type OmitInner<T extends string> = T extends `${infer TOuter}<${infer _TInner}>` ? `${TOuter}` : T;