@0xobelisk/sui-client 0.4.9

package/src/libs/suiInteractor/defaultConfig.ts

@@ -0,0 +1,32 @@
+import {
+  localnetConnection,
+  devnetConnection,
+  testnetConnection,
+  mainnetConnection,
+} from '@mysten/sui.js';
+import type { Connection } from '@mysten/sui.js';
+import type { NetworkType } from '../../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 getDefaultConnection = (
+  networkType: NetworkType = 'devnet'
+): Connection => {
+  switch (networkType) {
+    case 'localnet':
+      return localnetConnection;
+    case 'devnet':
+      return devnetConnection;
+    case 'testnet':
+      return testnetConnection;
+    case 'mainnet':
+      return mainnetConnection;
+    default:
+      return devnetConnection;
+  }
+};

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,302 @@
+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 { FaucetNetworkType, NetworkType, ObjectData } from '../../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 getEntitiesObjects(ids: string[]) {
+  //   const options = {
+  //     showContent: true,
+  //     showType: true,
+  //   };
+
+  //   for (const provider of this.providers) {
+  //     try {
+  //       const objects = await provider.multiGetObjects({ ids, options });
+  //       const parsedObjects = objects.map((object) => {
+  //         const objectId = getObjectId(object);
+  //         const objectFields = getObjectFields(object) as ObjectFieldType;
+  //         const index = objectFields.name;
+  //         const key = objectFields.value;
+  //         return {
+  //           objectId,
+  //           index,
+  //           key,
+  //         };
+  //       });
+  //       return parsedObjects as EntityData[];
+  //     } catch (err) {
+  //       await delay(2000);
+  //       console.warn(
+  //         `Failed to get EntitiesObjects with fullnode ${provider.connection.fullnode}: ${err}`
+  //       );
+  //     }
+  //   }
+  //   throw new Error('Failed to get EntitiesObjects with all fullnodes');
+  // }
+
+  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 DynamicFieldObject with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get DynamicFieldObject 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 DynamicFields with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get DynamicFields 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 OwnedObjects with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get OwnedObjects 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 NormalizedMoveModules with fullnode ${provider.connection.fullnode}: ${err}`
+        );
+      }
+    }
+    throw new Error('Failed to get NormalizedMoveModules 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

@@ -0,0 +1,245 @@
+import {
+  TransactionBlock,
+  SUI_SYSTEM_STATE_OBJECT_ID,
+  TransactionExpiration,
+  SuiObjectRef,
+  SharedObjectRef,
+  JsonRpcProvider,
+  TransactionType,
+  Transactions,
+  ObjectCallArg,
+} from '@mysten/sui.js';
+import { convertArgs } from './util';
+import type { SuiTxArg, SuiObjectArg, SuiVecTxArg } from '../../types';
+
+export class SuiTxBlock {
+  public txBlock: TransactionBlock;
+  constructor(transaction?: TransactionBlock) {
+    this.txBlock = new TransactionBlock(transaction);
+  }
+
+  //======== override methods of TransactionBlock ============
+
+  address(value: string) {
+    return this.txBlock.pure(value, 'address');
+  }
+  pure(value: unknown, type?: string) {
+    return this.txBlock.pure(value, type);
+  }
+  object(value: string | ObjectCallArg) {
+    return this.txBlock.object(value);
+  }
+  objectRef(ref: SuiObjectRef) {
+    return this.txBlock.objectRef(ref);
+  }
+  sharedObjectRef(ref: SharedObjectRef) {
+    return this.txBlock.sharedObjectRef(ref);
+  }
+  setSender(sender: string) {
+    return this.txBlock.setSender(sender);
+  }
+  setSenderIfNotSet(sender: string) {
+    return this.txBlock.setSenderIfNotSet(sender);
+  }
+  setExpiration(expiration?: TransactionExpiration) {
+    return this.txBlock.setExpiration(expiration);
+  }
+  setGasPrice(price: number | bigint) {
+    return this.txBlock.setGasPrice(price);
+  }
+  setGasBudget(budget: number | bigint) {
+    return this.txBlock.setGasBudget(budget);
+  }
+  setGasOwner(owner: string) {
+    return this.txBlock.setGasOwner(owner);
+  }
+  setGasPayment(payments: SuiObjectRef[]) {
+    return this.txBlock.setGasPayment(payments);
+  }
+
+  add(transaction: TransactionType) {
+    return this.txBlock.add(transaction);
+  }
+  serialize() {
+    return this.txBlock.serialize();
+  }
+  build(
+    params: {
+      provider?: JsonRpcProvider;
+      onlyTransactionKind?: boolean;
+    } = {}
+  ) {
+    return this.txBlock.build(params);
+  }
+  getDigest({ provider }: { provider?: JsonRpcProvider } = {}) {
+    return this.txBlock.getDigest({ provider });
+  }
+
+  get gas() {
+    return this.txBlock.gas;
+  }
+  get blockData() {
+    return this.txBlock.blockData;
+  }
+
+  transferObjects(objects: SuiObjectArg[], recipient: string) {
+    const tx = this.txBlock;
+    tx.transferObjects(convertArgs(this.txBlock, objects), tx.pure(recipient));
+    return this;
+  }
+  splitCoins(coin: SuiObjectArg, amounts: number[]) {
+    const tx = this.txBlock;
+    const coinObject = convertArgs(this.txBlock, [coin])[0];
+    const res = tx.splitCoins(
+      coinObject,
+      amounts.map((m) => tx.pure(m))
+    );
+    return amounts.map((_, i) => res[i]);
+  }
+  mergeCoins(destination: SuiObjectArg, sources: SuiObjectArg[]) {
+    const destinationObject = convertArgs(this.txBlock, [destination])[0];
+    const sourceObjects = convertArgs(this.txBlock, sources);
+    return this.txBlock.mergeCoins(destinationObject, sourceObjects);
+  }
+  publish(...args: Parameters<(typeof Transactions)['Publish']>) {
+    return this.txBlock.publish(...args);
+  }
+  upgrade(...args: Parameters<(typeof Transactions)['Upgrade']>) {
+    return this.txBlock.upgrade(...args);
+  }
+  makeMoveVec(...args: Parameters<(typeof Transactions)['MakeMoveVec']>) {
+    return this.txBlock.makeMoveVec(...args);
+  }
+
+  /**
+   * @description Move call
+   * @param target `${string}::${string}::${string}`, e.g. `0x3::sui_system::request_add_stake`
+   * @param args the arguments of the move call, such as `['0x1', '0x2']`
+   * @param typeArguments the type arguments of the move call, such as `['0x2::sui::SUI']`
+   */
+  moveCall(
+    target: string,
+    args: (SuiTxArg | SuiVecTxArg)[] = [],
+    typeArguments: string[] = []
+  ) {
+    // a regex for pattern `${string}::${string}::${string}`
+    const regex =
+      /(?<package>[a-zA-Z0-9]+)::(?<module>[a-zA-Z0-9_]+)::(?<function>[a-zA-Z0-9_]+)/;
+    const match = target.match(regex);
+    if (match === null)
+      throw new Error(
+        'Invalid target format. Expected `${string}::${string}::${string}`'
+      );
+    const convertedArgs = convertArgs(this.txBlock, args);
+    const tx = this.txBlock;
+    return tx.moveCall({
+      target: target as `${string}::${string}::${string}`,
+      arguments: convertedArgs,
+      typeArguments,
+    });
+  }
+
+  //======== enhance methods ============
+  transferSuiToMany(recipients: string[], amounts: number[]) {
+    // require recipients.length === amounts.length
+    if (recipients.length !== amounts.length) {
+      throw new Error(
+        'transferSuiToMany: recipients.length !== amounts.length'
+      );
+    }
+
+    const tx = this.txBlock;
+    const coins = tx.splitCoins(
+      tx.gas,
+      amounts.map((amount) => tx.pure(amount))
+    );
+    recipients.forEach((recipient, index) => {
+      tx.transferObjects([coins[index]], tx.pure(recipient));
+    });
+    return this;
+  }
+
+  transferSui(recipient: string, amount: number) {
+    return this.transferSuiToMany([recipient], [amount]);
+  }
+
+  takeAmountFromCoins(coins: SuiObjectArg[], amount: number) {
+    const tx = this.txBlock;
+    const coinObjects = convertArgs(this.txBlock, coins);
+    const mergedCoin = coinObjects[0];
+    if (coins.length > 1) {
+      tx.mergeCoins(mergedCoin, coinObjects.slice(1));
+    }
+    const [sendCoin] = tx.splitCoins(mergedCoin, [tx.pure(amount)]);
+    return [sendCoin, mergedCoin];
+  }
+
+  splitSUIFromGas(amounts: number[]) {
+    const tx = this.txBlock;
+    return tx.splitCoins(
+      tx.gas,
+      amounts.map((m) => tx.pure(m))
+    );
+  }
+
+  splitMultiCoins(coins: SuiObjectArg[], amounts: number[]) {
+    const tx = this.txBlock;
+    const coinObjects = convertArgs(this.txBlock, coins);
+    const mergedCoin = coinObjects[0];
+    if (coins.length > 1) {
+      tx.mergeCoins(mergedCoin, coinObjects.slice(1));
+    }
+    const splitedCoins = tx.splitCoins(
+      mergedCoin,
+      amounts.map((m) => tx.pure(m))
+    );
+    return { splitedCoins, mergedCoin };
+  }
+
+  transferCoinToMany(
+    inputCoins: SuiObjectArg[],
+    sender: string,
+    recipients: string[],
+    amounts: number[]
+  ) {
+    // require recipients.length === amounts.length
+    if (recipients.length !== amounts.length) {
+      throw new Error(
+        'transferSuiToMany: recipients.length !== amounts.length'
+      );
+    }
+    const tx = this.txBlock;
+    const { splitedCoins, mergedCoin } = this.splitMultiCoins(
+      inputCoins,
+      amounts
+    );
+    recipients.forEach((recipient, index) => {
+      tx.transferObjects([splitedCoins[index]], tx.pure(recipient));
+    });
+    tx.transferObjects([mergedCoin], tx.pure(sender));
+    return this;
+  }
+
+  transferCoin(
+    inputCoins: SuiObjectArg[],
+    sender: string,
+    recipient: string,
+    amount: number
+  ) {
+    return this.transferCoinToMany(inputCoins, sender, [recipient], [amount]);
+  }
+
+  stakeSui(amount: number, validatorAddr: string) {
+    const tx = this.txBlock;
+    const [stakeCoin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
+    tx.moveCall({
+      target: '0x3::sui_system::request_add_stake',
+      arguments: [
+        tx.object(SUI_SYSTEM_STATE_OBJECT_ID),
+        stakeCoin,
+        tx.pure(validatorAddr),
+      ],
+    });
+    return tx;
+  }
+}