@0xobelisk/sui-client 1.0.3 → 1.0.4

package/dist/libs/suiInteractor/defaultConfig.d.ts

@@ -0,0 +1,10 @@
+import { NetworkType } from 'src/types';
+export interface NetworkConfig {
+    fullNode: string;
+    graphql?: string;
+    network: string;
+    txExplorer: string;
+    accountExplorer: string;
+    explorer: string;
+}
+export declare const getDefaultURL: (networkType?: NetworkType) => NetworkConfig;

package/dist/libs/suiInteractor/index.d.ts

@@ -1 +1,3 @@
 export { SuiInteractor } from './suiInteractor';
+export { getDefaultURL } from './defaultConfig';
+export type { NetworkConfig } from './defaultConfig';

package/dist/libs/suiInteractor/suiInteractor.d.ts

@@ -17,6 +17,11 @@ export declare class SuiInteractor {
     constructor(fullNodeUrls: string[], network?: NetworkType);
     switchToNextClient(): void;
     sendTx(transactionBlock: Uint8Array | string, signature: string | string[]): Promise<SuiTransactionBlockResponse>;
+    waitForTransaction({ digest, timeout, pollInterval, }: {
+        digest: string;
+        timeout?: number;
+        pollInterval?: number;
+    }): Promise<SuiTransactionBlockResponse>;
     getObjects(ids: string[], options?: SuiObjectDataOptions): Promise<SuiObjectData[]>;
     getObject(id: string): Promise<SuiObjectData>;
     getDynamicFieldObject(parentId: string, name: RpcTypes.DynamicFieldName): Promise<RpcTypes.SuiObjectResponse>;

package/dist/libs/suiTxBuilder/index.d.ts

@@ -47,7 +47,7 @@ export declare class SuiTx {
                 resultIndex: number;
             })[];
             kind: "MoveCall";
-            target: `${string}::${string}::${string}`;
+            target: import("valibot").GenericSchema<`${string}::${string}::${string}`>;
         } | {
             address: {
                 kind: "Input";
@@ -336,9 +336,21 @@ export declare class SuiTx {
     transferSuiToMany(recipients: SuiAddressArg[], amounts: (SuiTxArg | number | bigint)[]): this;
     transferSui(address: SuiAddressArg, amount: SuiTxArg | number | bigint): this;
     takeAmountFromCoins(coins: SuiObjectArg[], amount: SuiTxArg | number | bigint): TransactionObjectArgument[];
-    splitSUIFromGas(amounts: SuiAmountsArg[]): import("@mysten/sui/transactions").TransactionResult;
+    splitSUIFromGas(amounts: SuiAmountsArg[]): {
+        $kind: "Result";
+        Result: number;
+    } & {
+        $kind: "NestedResult";
+        NestedResult: [number, number];
+    }[];
     splitMultiCoins(coins: SuiObjectArg[], amounts: SuiAmountsArg[]): {
-        splitedCoins: import("@mysten/sui/transactions").TransactionResult;
+        splitedCoins: {
+            $kind: "Result";
+            Result: number;
+        } & {
+            $kind: "NestedResult";
+            NestedResult: [number, number];
+        }[];
         mergedCoin: TransactionObjectArgument;
     };
     transferCoinToMany(coins: SuiObjectArg[], sender: SuiAddressArg, recipients: SuiAddressArg[], amounts: SuiAmountsArg[]): this;

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@ import type { Infer } from 'superstruct';
 import type { BcsType, SerializedBcs } from '@mysten/bcs';
 import type { TransactionArgument } from '@mysten/sui/transactions';
 import type { Transaction, TransactionObjectArgument, TransactionResult, Argument, Inputs } from '@mysten/sui/transactions';
-import type { SuiMoveNormalizedModules, DevInspectResults, SuiTransactionBlockResponse, DisplayFieldsResponse, SuiMoveNormalizedType, MoveStruct } from '@mysten/sui/client';
+import type { SuiMoveNormalizedModules, DevInspectResults, SuiTransactionBlockResponse, DisplayFieldsResponse, MoveStruct, SuiMoveNormalizedEnum, SuiMoveNormalizedStruct } from '@mysten/sui/client';
 import { SuiTx } from '../libs/suiTxBuilder';
 import { SuiMoveMoudleFuncType } from '../libs/suiContractFactory/types';
 export declare const ObjectContentFields: import("superstruct").Struct<Record<string, any>, null>;
@@ -79,24 +79,14 @@ export type MapMessageTx = Record<string, ContractTx>;
 export type MapMessageQuery = Record<string, ContractQuery>;
 export type MapMoudleFuncTx = Record<string, MapMessageTx>;
 export type MapMoudleFuncQuery = Record<string, MapMessageQuery>;
-export type MoveStructValueType = {
-    fields: {
-        type: SuiMoveNormalizedType;
-        name: string;
-    }[];
-    abilities: {
-        abilities: string[];
-    };
-    typeParameters: {
-        constraints: {
-            abilities: string[];
-        };
-        isPhantom: boolean;
-    }[];
-};
 export type MoveStructType = {
     objectId: string;
-    objectType: MoveStructValueType;
+    objectType: SuiMoveNormalizedStruct;
+    objectName: string;
+};
+export type MoveEnumType = {
+    objectId: string;
+    objectType: SuiMoveNormalizedEnum;
     objectName: string;
 };
 export type MapObjectStruct = Record<string, BcsType<any, any>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-client",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -37,8 +37,8 @@
     "src"
   ],
   "dependencies": {
-    "@mysten/bcs": "^1.0.4",
-    "@mysten/sui": "^1.7.0",
+    "@mysten/bcs": "^1.2.1",
+    "@mysten/sui": "^1.19.0",
     "@noble/curves": "^1.4.2",
     "@noble/hashes": "^1.4.0",
     "@scure/bip39": "^1.3.0",

package/src/dubhe.ts

@@ -9,6 +9,7 @@ import type {
   SuiMoveNormalizedModules,
   SuiMoveNormalizedType,
   SuiObjectData,
+  SuiMoveNormalizedModule,
 } from '@mysten/sui/client';
 import { SuiAccountManager } from './libs/suiAccountManager';
 import { SuiTx } from './libs/suiTxBuilder';
@@ -18,12 +19,14 @@ import {
   MoveStructType,
   DubheObjectContent,
   SuiDubheReturnType,
+  MoveEnumType,
 } from './types';
 import { SuiContractFactory } from './libs/suiContractFactory';
 import {
   SuiMoveMoudleFuncType,
   SuiMoveMoudleValueType,
 } from './libs/suiContractFactory/types';
+import { getDefaultURL, NetworkConfig } from './libs/suiInteractor';
 import {
   ContractQuery,
   ContractTx,
@@ -248,10 +251,38 @@ export class Dubhe {
         let loopFlag = false;
         Object.values(metadata as SuiMoveNormalizedModules).forEach(
           (moudlevalue) => {
-            const data = moudlevalue as SuiMoveMoudleValueType;
+            const data = moudlevalue as SuiMoveNormalizedModule;
             const moduleName = data.name;
             const objMoudleId = `${packageId}::${moduleName}`;
 
+            if (data.enums) {
+              Object.entries(data.enums).forEach(([enumName, enumType]) => {
+                const objectId = `${objMoudleId}::${enumName}`;
+                const bcsmeta: MoveEnumType = {
+                  objectId,
+                  objectName: enumName,
+                  objectType: enumType,
+                };
+                // console.log('--------');
+                // console.log(JSON.stringify(bcsmeta, null, 2));
+                // if (isUndefined(this.#object[objectId])) {
+                let bcsObj = this.#bcsenum(bcsmeta);
+                if (bcsObj.loopFlag === true) {
+                  loopFlag = bcsObj.loopFlag;
+                }
+                if (this.#object[objectId] === undefined) {
+                  this.#object[objectId] = bcsObj.bcs;
+                  this.#object[`vector<${objectId}>`] = bcs.vector(bcsObj.bcs);
+                  this.#object[`vector<vector<${objectId}>>`] = bcs.vector(
+                    bcs.vector(bcsObj.bcs)
+                  );
+                  this.#object[`0x1::option::Option<${objectId}>`] = bcs.option(
+                    bcsObj.bcs
+                  );
+                }
+              });
+            }
+
             Object.entries(data.structs).forEach(([objectName, objectType]) => {
               const objectId = `${objMoudleId}::${objectName}`;
               const bcsmeta: MoveStructType = {
@@ -373,6 +404,13 @@ export class Dubhe {
     return await this.inspectTxn(tx);
   };
 
+  #getVectorDepth = (field: SuiMoveNormalizedType): number => {
+    if (typeof field === 'object' && 'Vector' in field) {
+      return 1 + this.#getVectorDepth(field.Vector);
+    }
+    return 0;
+  };
+
   #bcs = (bcsmeta: MoveStructType) => {
     let loopFlag = false;
     const bcsJson: Record<string, BcsType<any, any>> = {};
@@ -483,40 +521,68 @@ export class Dubhe {
                 }
                 return;
               case 'Vector':
-                switch (value) {
-                  case 'U8':
-                    bcsJson[objName] = bcs.vector(bcs.u8());
-                    return;
-                  case 'U16':
-                    bcsJson[objName] = bcs.vector(bcs.u16());
-                    return;
-                  case 'U32':
-                    bcsJson[objName] = bcs.vector(bcs.u32());
-                    return;
-                  case 'U64':
-                    bcsJson[objName] = bcs.vector(bcs.u64());
-                    return;
-                  case 'U128':
-                    bcsJson[objName] = bcs.vector(bcs.u128());
-                    return;
-                  case 'U256':
-                    bcsJson[objName] = bcs.vector(bcs.u256());
-                    return;
-                  case 'Bool':
-                    bcsJson[objName] = bcs.vector(bcs.bool());
-                    return;
-                  case 'Address':
-                    bcsJson[objName] = bcs.vector(
-                      bcs.bytes(32).transform({
-                        // To change the input type, you need to provide a type definition for the input
-                        input: (val: string) => fromHEX(val),
-                        output: (val) => toHEX(val),
-                      })
-                    );
+                if (typeof value === 'string') {
+                  switch (value) {
+                    case 'U8':
+                      bcsJson[objName] = bcs.vector(bcs.u8());
+                      return;
+                    case 'U16':
+                      bcsJson[objName] = bcs.vector(bcs.u16());
+                      return;
+                    case 'U32':
+                      bcsJson[objName] = bcs.vector(bcs.u32());
+                      return;
+                    case 'U64':
+                      bcsJson[objName] = bcs.vector(bcs.u64());
+                      return;
+                    case 'U128':
+                      bcsJson[objName] = bcs.vector(bcs.u128());
+                      return;
+                    case 'U256':
+                      bcsJson[objName] = bcs.vector(bcs.u256());
+                      return;
+                    case 'Bool':
+                      bcsJson[objName] = bcs.vector(bcs.bool());
+                      return;
+                    case 'Address':
+                      bcsJson[objName] = bcs.vector(
+                        bcs.bytes(32).transform({
+                          // To change the input type, you need to provide a type definition for the input
+                          input: (val: string) => fromHEX(val),
+                          output: (val) => toHEX(val),
+                        })
+                      );
+                      return;
+                    default:
+                    // throw new Error('Unsupported type');
+                  }
+                }
+                if (typeof value === 'object') {
+                  const vectorDepth = this.#getVectorDepth(value);
+                  let innerType = value;
+                  for (let i = 0; i < vectorDepth; i++) {
+                    innerType = innerType.Vector;
+                  }
+
+                  if ('Struct' in innerType) {
+                    const structType = innerType.Struct;
+                    const structId = `${structType.address}::${structType.module}::${structType.name}`;
+
+                    let bcsType = this.#object[structId];
+                    if (!bcsType) {
+                      loopFlag = true;
+                      return;
+                    }
+                    let baseType = bcsType;
+                    for (let i = 0; i <= vectorDepth; i++) {
+                      baseType = bcs.vector(baseType);
+                    }
+
+                    bcsJson[objName] = baseType;
                     return;
-                  default:
-                  // throw new Error('Unsupported type');
+                  }
                 }
+                return;
               case 'TypeParameter':
                 bcsJson[objName] = bcs.u128();
                 return;
@@ -573,6 +639,233 @@ export class Dubhe {
     };
   };
 
+  #bcsenum = (bcsmeta: MoveEnumType) => {
+    let loopFlag = false;
+    const variantJson: Record<string, BcsType<any, any> | null> = {};
+
+    // const databcs = bcs.vector(
+    //   bcs.struct('Account', {
+    //     balance: bcs.u64(),
+    //     status: bcs.enum('AccountStatus', {
+    //       Liquid: null,
+    //       Frozen: null,
+    //       Blocked: null,
+    //     }),
+    //   })
+    // );
+
+    Object.entries(bcsmeta.objectType.variants).forEach(([name, type]) => {
+      if (type.length > 0) {
+        Object.entries(type).forEach(([index, value]) => {
+          const objType: SuiMoveNormalizedType = value.type;
+          const objName = value.name;
+          switch (typeof objType) {
+            case 'object':
+              for (const [key, value] of Object.entries(objType)) {
+                switch (key) {
+                  case 'Struct':
+                    const structType = value as {
+                      address: string;
+                      module: string;
+                      name: string;
+                      typeArguments: SuiMoveNormalizedType[];
+                    };
+                    if (
+                      structType.address === '0x1' &&
+                      structType.module === 'ascii' &&
+                      structType.name === 'String'
+                    ) {
+                      variantJson[objName] = bcs.string();
+                      return;
+                    } else if (
+                      structType.address === '0x2' &&
+                      structType.module === 'object' &&
+                      structType.name === 'UID'
+                    ) {
+                      variantJson[objName] = bcs
+                        .fixedArray(32, bcs.u8())
+                        .transform({
+                          input: (id: string) => fromHEX(id),
+                          output: (id) => toHEX(Uint8Array.from(id)),
+                        });
+                      return;
+                    } else if (
+                      structType.address === '0x2' &&
+                      structType.module === 'object' &&
+                      structType.name === 'ID'
+                    ) {
+                      variantJson[objName] = bcs
+                        .fixedArray(32, bcs.u8())
+                        .transform({
+                          input: (id: string) => fromHEX(id),
+                          output: (id) => toHEX(Uint8Array.from(id)),
+                        });
+                      return;
+                    } else if (
+                      structType.address === '0x2' &&
+                      structType.module === 'bag' &&
+                      structType.name === 'Bag'
+                    ) {
+                      variantJson[objName] = bcs
+                        .fixedArray(32, bcs.u8())
+                        .transform({
+                          input: (id: string) => fromHEX(id),
+                          output: (id) => toHEX(Uint8Array.from(id)),
+                        });
+                      return;
+                    } else if (
+                      structType.address === '0x1' &&
+                      structType.module === 'option' &&
+                      structType.name === 'Option'
+                    ) {
+                      switch (structType.typeArguments[0]) {
+                        case 'U8':
+                          variantJson[objName] = bcs.option(bcs.u8());
+                          return;
+                        case 'U16':
+                          variantJson[objName] = bcs.option(bcs.u16());
+                          return;
+                        case 'U32':
+                          variantJson[objName] = bcs.option(bcs.u32());
+                          return;
+                        case 'U64':
+                          variantJson[objName] = bcs.option(bcs.u64());
+                          return;
+                        case 'U128':
+                          variantJson[objName] = bcs.option(bcs.u128());
+                          return;
+                        case 'U256':
+                          variantJson[objName] = bcs.option(bcs.u256());
+                          return;
+                        case 'Bool':
+                          variantJson[objName] = bcs.option(bcs.bool());
+                          return;
+                        case 'Address':
+                          variantJson[objName] = bcs.option(
+                            bcs.bytes(32).transform({
+                              // To change the input type, you need to provide a type definition for the input
+                              input: (val: string) => fromHEX(val),
+                              output: (val) => toHEX(val),
+                            })
+                          );
+                          return;
+                        default:
+                        // throw new Error('Unsupported type');
+                      }
+                    } else {
+                      if (
+                        this.object[
+                          `${structType.address}::${structType.module}::${structType.name}`
+                        ] === undefined
+                      ) {
+                        loopFlag = true;
+                      } else {
+                        variantJson[objName] =
+                          this.object[
+                            `${structType.address}::${structType.module}::${structType.name}`
+                          ];
+                        return;
+                      }
+                    }
+                    return;
+                  case 'Vector':
+                    if (typeof value === 'string') {
+                      switch (value) {
+                        case 'U8':
+                          variantJson[objName] = bcs.vector(bcs.u8());
+                          return;
+                        case 'U16':
+                          variantJson[objName] = bcs.vector(bcs.u16());
+                          return;
+                        case 'U32':
+                          variantJson[objName] = bcs.vector(bcs.u32());
+                          return;
+                        case 'U64':
+                          variantJson[objName] = bcs.vector(bcs.u64());
+                          return;
+                        case 'U128':
+                          variantJson[objName] = bcs.vector(bcs.u128());
+                          return;
+                        case 'U256':
+                          variantJson[objName] = bcs.vector(bcs.u256());
+                          return;
+                        case 'Bool':
+                          variantJson[objName] = bcs.vector(bcs.bool());
+                          return;
+                        case 'Address':
+                          variantJson[objName] = bcs.vector(
+                            bcs.bytes(32).transform({
+                              // To change the input type, you need to provide a type definition for the input
+                              input: (val: string) => fromHEX(val),
+                              output: (val) => toHEX(val),
+                            })
+                          );
+                          return;
+                        default:
+                        // throw new Error('Unsupported type');
+                      }
+                    }
+                  // if (typeof value === 'object') {
+                  // }
+                  case 'TypeParameter':
+                    variantJson[objName] = bcs.u128();
+                    return;
+                  // case 'Reference':
+
+                  // case 'MutableReference':
+
+                  default:
+                    throw new Error('Unsupported type');
+                }
+              }
+              return;
+            case 'string':
+              switch (objType) {
+                case 'U8':
+                  variantJson[objName] = bcs.u8();
+                  return;
+                case 'U16':
+                  variantJson[objName] = bcs.u16();
+                  return;
+                case 'U32':
+                  variantJson[objName] = bcs.u32();
+                  return;
+                case 'U64':
+                  variantJson[objName] = bcs.u64();
+                  return;
+                case 'U128':
+                  variantJson[objName] = bcs.u128();
+                  return;
+                case 'U256':
+                  variantJson[objName] = bcs.u256();
+                  return;
+                case 'Bool':
+                  variantJson[objName] = bcs.bool();
+                  return;
+                case 'Address':
+                  variantJson[objName] = bcs.bytes(32).transform({
+                    // To change the input type, you need to provide a type definition for the input
+                    input: (val: string) => fromHEX(val),
+                    output: (val) => toHEX(val),
+                  });
+                  return;
+                default:
+                  return;
+              }
+            default:
+              throw new Error('Unsupported type');
+          }
+        });
+      } else {
+        variantJson[name] = null;
+      }
+    });
+    return {
+      bcs: bcs.enum(bcsmeta.objectName, variantJson),
+      loopFlag,
+    };
+  };
+
   view(dryResult: DevInspectResults) {
     let returnValues = [];
 
@@ -652,6 +945,10 @@ export class Dubhe {
         }
 
         if (this.#object[baseType]) {
+          // console.log('=========== here');
+          // console.log(baseType);
+          // console.log(JSON.stringify(this.#object[baseType], null, 2));
+          // console.log('-------------');
           returnValues.push(this.#object[baseType].parse(value));
           continue;
         }
@@ -698,21 +995,45 @@ export class Dubhe {
   }
 
   async state({
+    tx,
+    schema,
+    params,
+  }: {
+    tx: Transaction;
+    schema: string;
+    params: any[];
+  }): Promise<any[] | undefined> {
+    const moduleName = `schema`;
+    const functionName = `get_${schema}`;
+
+    let queryResponse = undefined;
+    try {
+      queryResponse = (await this.query[moduleName][functionName]({
+        tx,
+        params,
+      })) as DevInspectResults;
+
+      if (queryResponse.effects.status.status !== 'success') {
+        return undefined;
+      }
+    } catch {
+      return undefined;
+    }
+    return this.view(queryResponse);
+  }
+
+  async parseState({
     schema,
-    field,
     objectId,
     storageType,
     params,
   }: {
     schema: string;
-    field: string;
     objectId: string;
     storageType: string; // 'StorageValue<V>' | 'StorageMap<K, V>' | 'StorageDoubleMap<K1, K2, V>'
     params: any[];
-  }) {
+  }): Promise<any[] | undefined> {
     const tx = new Transaction();
-    const moduleName = `${schema}_schema`;
-    const functionName = `get_${field}`;
     const schemaObject = tx.object(objectId);
     // Parse storage type
     const storageValueMatch = storageType.match(/^StorageValue<(.+)>$/);
@@ -753,11 +1074,11 @@ export class Dubhe {
         `Invalid storage type: ${storageType}. Must be StorageValue<V>, StorageMap<K,V>, or StorageDoubleMap<K1,K2,V>`
       );
     }
-    const queryResponse = (await this.query[moduleName][functionName]({
+    return this.state({
       tx,
+      schema,
       params: processedParams,
-    })) as DevInspectResults;
-    return this.view(queryResponse);
+    });
   }
 
   #processKeyParameter(tx: Transaction, keyType: string, value: any) {
@@ -805,12 +1126,11 @@ export class Dubhe {
   }
 
   /**
-   * if derivePathParams is not provided or mnemonics is empty, it will return the keypair.
    * else:
    * it will generate signer from the mnemonic with the given derivePathParams.
    * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
    */
-  getKeypair(derivePathParams?: DerivePathParams) {
+  getSigner(derivePathParams?: DerivePathParams) {
     return this.accountManager.getKeyPair(derivePathParams);
   }
 
@@ -845,6 +1165,23 @@ export class Dubhe {
   getNetwork() {
     return this.suiInteractor.network;
   }
+
+  getNetworkConfig(): NetworkConfig {
+    return getDefaultURL(this.getNetwork());
+  }
+
+  getTxExplorerUrl(txHash: string) {
+    return this.getNetworkConfig().txExplorer.replace(':txHash', txHash);
+  }
+
+  getAccountExplorerUrl(address: string) {
+    return this.getNetworkConfig().accountExplorer.replace(':address', address);
+  }
+
+  getExplorerUrl() {
+    return this.getNetworkConfig().explorer;
+  }
+
   /**
    * Request some SUI from faucet
    * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
@@ -907,7 +1244,7 @@ export class Dubhe {
       txBlock instanceof Transaction
         ? await txBlock.build({ client: this.client() })
         : txBlock;
-    const keyPair = this.getKeypair(derivePathParams);
+    const keyPair = this.getSigner(derivePathParams);
     return await keyPair.signTransaction(txBytes);
   }
 
@@ -916,14 +1253,18 @@ export class Dubhe {
     derivePathParams?: DerivePathParams
   ): Promise<SuiTransactionBlockResponse> {
     const { bytes, signature } = await this.signTxn(tx, derivePathParams);
-    return this.suiInteractor.sendTx(bytes, signature);
+    return this.sendTx(bytes, signature);
   }
 
-  async sendTxn(
-    transactionBlock: Uint8Array | string,
+  async sendTx(
+    transaction: Uint8Array | string,
     signature: string | string[]
   ): Promise<SuiTransactionBlockResponse> {
-    return this.suiInteractor.sendTx(transactionBlock, signature);
+    return this.suiInteractor.sendTx(transaction, signature);
+  }
+
+  async waitForTransaction(digest: string) {
+    return this.suiInteractor.waitForTransaction({ digest });
   }
 
   /**