@0xobelisk/client 0.0.9 → 0.1.1

package/dist/types/index.d.ts

@@ -1,13 +1,17 @@
-import { SuiMoveNormalizedModules, DevInspectResults, SuiTransactionBlockResponse, TransactionBlock } from "@mysten/sui.js";
-import type { NetworkType as SuiNetworkType } from '../libs/suiRpcProvider/types';
-export type { DerivePathParams } from '../libs/suiAccountManager/types';
+import { Infer } from 'superstruct';
+import { DisplayFieldsResponse, ObjectCallArg, ObjectContentFields, SharedObjectRef, SuiObjectRef, TransactionArgument, TransactionBlock, SuiTransactionBlockResponse, DevInspectResults, SuiMoveNormalizedModules } from '@mysten/sui.js';
 import { SuiMoveMoudleFuncType } from '../libs/suiContractFactory/types';
-export type { SuiTxArg, SuiVecTxArg, SuiObjectArg, } from '../libs/suiTxBuilder/types';
-export type NetworkType = SuiNetworkType;
+export type ObeliskObjectData = {
+    objectId: string;
+    objectType: string;
+    objectVersion: number;
+    objectDisplay: DisplayFieldsResponse;
+    objectFields: ObjectContentFields;
+};
 export type ObeliskParams = {
     mnemonics?: string;
     secretKey?: string;
-    fullnodeUrl?: string;
+    fullnodeUrls?: string[];
     faucetUrl?: string;
     networkType?: NetworkType;
     packageId?: string;
@@ -70,3 +74,41 @@ export type MapMoudleFuncTx = Record<string, MapMessageTx>;
 export type MapMoudleFuncQuery = Record<string, MapMessageQuery>;
 export type MapMoudleFuncTest = Record<string, Record<string, string>>;
 export type MapMoudleFuncQueryTest = Record<string, Record<string, string>>;
+export type AccountMangerParams = {
+    mnemonics?: string;
+    secretKey?: string;
+};
+export type DerivePathParams = {
+    accountIndex?: number;
+    isExternal?: boolean;
+    addressIndex?: number;
+};
+export type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+export type FaucetNetworkType = 'testnet' | 'devnet' | 'localnet';
+export type SuiKitParams = {
+    mnemonics?: string;
+    secretKey?: string;
+    fullnodeUrls?: string[];
+    faucetUrl?: string;
+    networkType?: NetworkType;
+};
+export type ObjectData = {
+    objectId: string;
+    objectType: string;
+    objectVersion: number;
+    objectDigest: string;
+    initialSharedVersion?: number;
+    objectDisplay: DisplayFieldsResponse;
+    objectFields: ObjectContentFields;
+};
+export type SuiTxArg = Infer<typeof TransactionArgument> | Infer<typeof ObjectCallArg> | string | number | bigint | boolean;
+export type SuiObjectArg = SharedObjectRef | Infer<typeof SuiObjectRef> | string | Infer<typeof ObjectCallArg> | Infer<typeof TransactionArgument>;
+export type SuiVecTxArg = {
+    value: SuiTxArg[];
+    vecType: SuiInputTypes;
+} | SuiTxArg[];
+/**
+ * These are the basics types that can be used in the SUI
+ */
+export type SuiBasicTypes = 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256';
+export type SuiInputTypes = 'object' | SuiBasicTypes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/client",
-  "version": "0.0.9",
+  "version": "0.1.1",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -58,7 +58,7 @@
   },
   "dependencies": {
     "@mysten/bcs": "^0.7.3",
-    "@mysten/sui.js": "^0.37.1",
+    "@mysten/sui.js": "^0.41.0",
     "@obelisk/common": "link:../common",
     "@scure/bip39": "^1.2.1",
     "assert": "^2.0.0",
@@ -71,7 +71,7 @@
     "ts-retry-promise": "^0.7.0"
   },
   "peerDependencies": {
-    "@mysten/sui.js": "^0.37.1"
+    "@mysten/sui.js": "^0.41.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^17.6.6",

package/src/index.ts

@@ -3,10 +3,11 @@ export {
   SUI_CLOCK_OBJECT_ID,
   SUI_SYSTEM_STATE_OBJECT_ID,
 } from '@mysten/sui.js';
+export { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
+export { fromB64, toB64 } from '@mysten/sui.js';
 export { Obelisk } from './obelisk';
 export { SuiAccountManager } from './libs/suiAccountManager';
 export { SuiTxBlock } from './libs/suiTxBuilder';
-export { SuiRpcProvider } from './libs/suiRpcProvider';
 export { SuiContractFactory } from './libs/suiContractFactory';
 export { getMetadata } from './metadata';
 export type * from './types';

package/src/libs/suiAccountManager/index.ts

@@ -2,7 +2,7 @@ import { Ed25519Keypair } from '@mysten/sui.js';
 import { getKeyPair } from './keypair';
 import { hexOrBase64ToUint8Array, normalizePrivateKey } from './util';
 import { generateMnemonic } from './crypto';
-import type { AccountMangerParams, DerivePathParams } from './types';
+import type { AccountMangerParams, DerivePathParams } from 'src/types';
 
 export class SuiAccountManager {
   private mnemonics: string;

package/src/libs/suiAccountManager/keypair.ts

@@ -1,5 +1,5 @@
-import { Ed25519Keypair } from '@mysten/sui.js';
-import type { DerivePathParams } from './types';
+import { Ed25519Keypair, fromB64 } from '@mysten/sui.js';
+import type { DerivePathParams } from 'src/types';
 
 /**
  * @description Get ed25519 derive path for SUI

package/src/libs/suiContractFactory/index.ts

@@ -88,7 +88,6 @@ export class SuiContractFactory {
       }
     );
   }
-  async worldCall() {}
 
   //   async call(arguments: ({
   //     kind: "Input";

package/src/libs/{suiRpcProvider/defaultChainConfigs.ts → suiInteractor/defaultConfig.ts}

@@ -5,14 +5,16 @@ import {
   mainnetConnection,
 } from '@mysten/sui.js';
 import type { Connection } from '@mysten/sui.js';
-import type { NetworkType } from './types';
+import type { NetworkType } from 'src/types';
+export const defaultGasBudget = 10 ** 8; // 0.1 SUI, should be enough for most of the transactions
+export const defaultGasPrice = 1000; // 1000 MIST
 
 /**
  * @description Get the default fullnode url and faucet url for the given network type
  * @param networkType, 'testnet' | 'mainnet' | 'devnet' | 'localnet', default is 'devnet'
  * @returns { fullNode: string, websocket: string, faucet?: string }
  */
-export const getDefaultNetworkParams = (
+export const getDefaultConnection = (
   networkType: NetworkType = 'devnet'
 ): Connection => {
   switch (networkType) {

package/src/libs/suiInteractor/index.ts

@@ -0,0 +1,2 @@
+export { SuiInteractor } from './suiInteractor';
+export { getDefaultConnection } from './defaultConfig';

package/src/libs/suiInteractor/suiInteractor.ts

@@ -0,0 +1,269 @@
+import {
+  SuiTransactionBlockResponse,
+  SuiTransactionBlockResponseOptions,
+  JsonRpcProvider,
+  Connection,
+  getObjectDisplay,
+  getObjectFields,
+  getObjectId,
+  getObjectType,
+  getObjectVersion,
+  getSharedObjectInitialVersion,
+  DynamicFieldName,
+  SuiAddress
+} from '@mysten/sui.js';
+import { requestSuiFromFaucetV0, getFaucetHost } from '@mysten/sui.js/faucet';
+import { SuiClient, getFullnodeUrl, GetBalanceParams } from '@mysten/sui.js/client';
+import { FaucetNetworkType, NetworkType, ObjectData } from 'src/types';
+import { SuiOwnedObject, SuiSharedObject } from '../suiModel';
+import { delay } from './util';
+
+/**
+ * `SuiTransactionSender` is used to send transaction with a given gas coin.
+ * It always uses the gas coin to pay for the gas,
+ * and update the gas coin after the transaction.
+ */
+export class SuiInteractor {
+  public readonly providers: JsonRpcProvider[];
+  public currentProvider: JsonRpcProvider;
+  public network?: NetworkType;
+
+  constructor(fullNodeUrls: string[], network?: NetworkType) {
+    if (fullNodeUrls.length === 0)
+      throw new Error('fullNodeUrls must not be empty');
+    this.providers = fullNodeUrls.map(
+      (url) => new JsonRpcProvider(new Connection({ fullnode: url }))
+    );
+    this.currentProvider = this.providers[0];
+    this.network = network;
+  }
+
+  switchToNextProvider() {
+    const currentProviderIdx = this.providers.indexOf(this.currentProvider);
+    this.currentProvider =
+      this.providers[(currentProviderIdx + 1) % this.providers.length];
+  }
+
+  async sendTx(
+    transactionBlock: Uint8Array | string,
+    signature: string | string[]
+  ): Promise<SuiTransactionBlockResponse> {
+    const txResOptions: SuiTransactionBlockResponseOptions = {
+      showEvents: true,
+      showEffects: true,
+      showObjectChanges: true,
+      showBalanceChanges: true,
+    };
+
+    // const currentProviderIdx = this.providers.indexOf(this.currentProvider);
+    // const providers = [
+    //   ...this.providers.slice(currentProviderIdx, this.providers.length),
+    //   ...this.providers.slice(0, currentProviderIdx),
+    // ]
+
+    for (const provider of this.providers) {
+      try {
+        const res = await provider.executeTransactionBlock({
+          transactionBlock,
+          signature,
+          options: txResOptions,
+        });
+        return res;
+      } catch (err) {
+        console.warn(
+          `Failed to send transaction with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+        await delay(2000);
+      }
+    }
+    throw new Error('Failed to send transaction with all fullnodes');
+  }
+  async getObjects(ids: string[]) {
+    const options = {
+      showContent: true,
+      showDisplay: true,
+      showType: true,
+      showOwner: true,
+    };
+
+    // const currentProviderIdx = this.providers.indexOf(this.currentProvider);
+    // const providers = [
+    //   ...this.providers.slice(currentProviderIdx, this.providers.length),
+    //   ...this.providers.slice(0, currentProviderIdx),
+    // ]
+
+    for (const provider of this.providers) {
+      try {
+        const objects = await provider.multiGetObjects({ ids, options });
+        const parsedObjects = objects.map((object) => {
+          const objectId = getObjectId(object);
+          const objectType = getObjectType(object);
+          const objectVersion = getObjectVersion(object);
+          const objectDigest = object.data ? object.data.digest : undefined;
+          const initialSharedVersion = getSharedObjectInitialVersion(object);
+          const objectFields = getObjectFields(object);
+          const objectDisplay = getObjectDisplay(object);
+          return {
+            objectId,
+            objectType,
+            objectVersion,
+            objectDigest,
+            objectFields,
+            objectDisplay,
+            initialSharedVersion,
+          };
+        });
+        return parsedObjects as ObjectData[];
+      } catch (err) {
+        await delay(2000);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get objects with all fullnodes');
+  }
+
+  async getObject(id: string) {
+    const objects = await this.getObjects([id]);
+    return objects[0];
+  }
+
+
+  async getDynamicFieldObject(parentId: string, name: string | DynamicFieldName) {
+    for (const provider of this.providers) {
+      try {
+        return provider.getDynamicFieldObject({ parentId, name })
+      } catch (err) {
+        await delay(2000);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get objects with all fullnodes');
+  }
+
+  async getDynamicFields(parentId: string, cursor?: string, limit?: number) {
+    for (const provider of this.providers) {
+      try {
+        return provider.getDynamicFields({ parentId, cursor, limit })
+      } catch (err) {
+        await delay(2000);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get objects with all fullnodes');
+  }
+
+  async getOwnedObjects(owner: SuiAddress, cursor?: string, limit?: number) {
+    for (const provider of this.providers) {
+      try {
+        return await provider.getOwnedObjects({ owner, cursor, limit });
+      } catch (err) {
+        await delay(2000);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get objects with all fullnodes');
+  }
+
+
+  async getNormalizedMoveModulesByPackage(packageId: string) {
+    for (const provider of this.providers) {
+      try {
+        return provider.getNormalizedMoveModulesByPackage({package: packageId});
+
+      } catch (err) {
+        await delay(2000);
+        console.warn(
+          `Failed to get objects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get objects with all fullnodes');
+  }
+
+  /**
+   * @description Update objects in a batch
+   * @param suiObjects
+   */
+  async updateObjects(suiObjects: (SuiOwnedObject | SuiSharedObject)[]) {
+    const objectIds = suiObjects.map((obj) => obj.objectId);
+    const objects = await this.getObjects(objectIds);
+    for (const object of objects) {
+      const suiObject = suiObjects.find(
+        (obj) => obj.objectId === object.objectId
+      );
+      if (suiObject instanceof SuiSharedObject) {
+        suiObject.initialSharedVersion = object.initialSharedVersion;
+      } else if (suiObject instanceof SuiOwnedObject) {
+        suiObject.version = object.objectVersion;
+        suiObject.digest = object.objectDigest;
+      }
+    }
+  }
+
+  /**
+   * @description Select coins that add up to the given amount.
+   * @param addr the address of the owner
+   * @param amount the amount that is needed for the coin
+   * @param coinType the coin type, default is '0x2::SUI::SUI'
+   */
+  async selectCoins(
+    addr: string,
+    amount: number,
+    coinType: string = '0x2::SUI::SUI'
+  ) {
+    const selectedCoins: {
+      objectId: string;
+      digest: string;
+      version: string;
+    }[] = [];
+    let totalAmount = 0;
+    let hasNext = true,
+      nextCursor: string | null = null;
+    while (hasNext && totalAmount < amount) {
+      const coins = await this.currentProvider.getCoins({
+        owner: addr,
+        coinType: coinType,
+        cursor: nextCursor,
+      });
+      // Sort the coins by balance in descending order
+      coins.data.sort((a, b) => parseInt(b.balance) - parseInt(a.balance));
+      for (const coinData of coins.data) {
+        selectedCoins.push({
+          objectId: coinData.coinObjectId,
+          digest: coinData.digest,
+          version: coinData.version,
+        });
+        totalAmount = totalAmount + parseInt(coinData.balance);
+        if (totalAmount >= amount) {
+          break;
+        }
+      }
+
+      nextCursor = coins.nextCursor;
+      hasNext = coins.hasNextPage;
+    }
+
+    if (!selectedCoins.length) {
+      throw new Error('No valid coins found for the transaction.');
+    }
+    return selectedCoins;
+  }
+
+  async requestFaucet(address: SuiAddress, network: FaucetNetworkType) {
+    await requestSuiFromFaucetV0({
+      host: getFaucetHost(network),
+      recipient: address,
+    });
+    // let params = {
+    //   owner: address
+    // } as GetBalanceParams;
+  }
+}

package/src/libs/suiInteractor/util.ts

@@ -0,0 +1,2 @@
+export const delay = (ms: number) =>
+  new Promise((resolve) => setTimeout(resolve, ms));

package/src/libs/suiModel/index.ts

@@ -0,0 +1,2 @@
+export { SuiOwnedObject } from './suiOwnedObject';
+export { SuiSharedObject } from './suiSharedObject';

package/src/libs/suiModel/suiOwnedObject.ts

@@ -0,0 +1,62 @@
+import { Infer } from 'superstruct';
+import {
+  getObjectChanges,
+  SuiTransactionBlockResponse,
+  ObjectCallArg,
+  ObjectId,
+} from '@mysten/sui.js';
+
+export class SuiOwnedObject {
+  public readonly objectId: string;
+  public version?: number | string;
+  public digest?: string;
+
+  constructor(param: { objectId: string; version?: string; digest?: string }) {
+    this.objectId = param.objectId;
+    this.version = param.version;
+    this.digest = param.digest;
+  }
+
+  /**
+   * Check if the object is fully initialized.
+   * So that when it's used as an input, it won't be necessary to fetch from fullnode again.
+   * Which can save time when sending transactions.
+   */
+  isFullObject(): boolean {
+    return !!this.version && !!this.digest;
+  }
+
+  asCallArg(): Infer<typeof ObjectCallArg> | Infer<typeof ObjectId> {
+    if (!this.version || !this.digest) {
+      return this.objectId;
+    }
+    return {
+      Object: {
+        ImmOrOwned: {
+          objectId: this.objectId,
+          version: this.version,
+          digest: this.digest,
+        },
+      },
+    };
+  }
+
+  /**
+   * Update object version & digest based on the transaction response.
+   * @param txResponse
+   */
+  updateFromTxResponse(txResponse: SuiTransactionBlockResponse) {
+    const changes = getObjectChanges(txResponse);
+    if (!changes) {
+      throw new Error('Bad transaction response!');
+    }
+    for (const change of changes) {
+      if (change.type === 'mutated' && change.objectId === this.objectId) {
+        this.digest = change.digest;
+        this.version = change.version;
+        return;
+      }
+    }
+    throw new Error('Could not find object in transaction response!');
+  }
+}

package/src/libs/suiModel/suiSharedObject.ts

@@ -0,0 +1,33 @@
+import { Infer } from 'superstruct';
+import { ObjectCallArg, ObjectId } from '@mysten/sui.js';
+
+export class SuiSharedObject {
+  public readonly objectId: string;
+  public initialSharedVersion?: number | string;
+
+  constructor(param: {
+    objectId: string;
+    initialSharedVersion?: number;
+    mutable?: boolean;
+  }) {
+    this.objectId = param.objectId;
+    this.initialSharedVersion = param.initialSharedVersion;
+  }
+
+  asCallArg(
+    mutable: boolean = false
+  ): Infer<typeof ObjectCallArg> | Infer<typeof ObjectId> {
+    if (!this.initialSharedVersion) {
+      return this.objectId;
+    }
+    return {
+      Object: {
+        Shared: {
+          objectId: this.objectId,
+          initialSharedVersion: this.initialSharedVersion,
+          mutable,
+        },
+      },
+    };
+  }
+}

package/src/libs/suiTxBuilder/index.ts

@@ -10,7 +10,7 @@ import {
   ObjectCallArg,
 } from '@mysten/sui.js';
 import { convertArgs } from './util';
-import type { SuiTxArg, SuiObjectArg, SuiVecTxArg } from './types';
+import type { SuiTxArg, SuiObjectArg, SuiVecTxArg } from 'src/types';
 
 export class SuiTxBlock {
   public txBlock: TransactionBlock;

package/src/libs/suiTxBuilder/util.ts

@@ -3,7 +3,7 @@ import {
   TransactionArgument,
   TransactionBlock,
 } from '@mysten/sui.js';
-import { SuiTxArg, SuiInputTypes } from './types';
+import { SuiTxArg, SuiInputTypes } from 'src/types';
 
 export const getDefaultSuiInputType = (value: any): SuiInputTypes => {
   if (typeof value === 'string' && value.startsWith('0x')) {

package/src/metadata/index.ts

@@ -1,14 +1,14 @@
 import { SuiMoveNormalizedModules } from '@mysten/sui.js';
-import { SuiRpcProvider } from '../libs/suiRpcProvider';
-import { NetworkType } from '../libs/suiRpcProvider/types';
+import { SuiInteractor, getDefaultConnection } from '../libs/suiInteractor';
 
-export async function getMetadata(networkType: NetworkType, packageId: string) {
-  const rpcProvider = new SuiRpcProvider({
-    networkType,
-  });
+import { NetworkType } from 'src/types';
 
+export async function getMetadata(networkType: NetworkType, packageId: string) {
+  // Init the rpc provider
+  const fullnodeUrls = [getDefaultConnection(networkType).fullnode];
+  const suiInteractor = new SuiInteractor(fullnodeUrls);
   if (packageId !== undefined) {
-    const jsonData = await rpcProvider.getNormalizedMoveModulesByPackage(packageId);
+    const jsonData = await suiInteractor.getNormalizedMoveModulesByPackage(packageId);
 
     return jsonData as SuiMoveNormalizedModules;
   } else {