@0xobelisk/client 0.4.7 → 1.2.0-pre.100

package/src/libs/suiInteractor/suiInteractor.ts

@@ -1,319 +0,0 @@
-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,
-  ObjectFieldType,
-  EntityData,
-} 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,
-    };
-
-    // 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 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 objects with fullnode ${provider.connection.fullnode}: ${err}`
-        );
-      }
-    }
-    throw new Error('Failed to get objects 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 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

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

package/src/libs/suiModel/index.ts

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

package/src/libs/suiModel/suiOwnedObject.ts

@@ -1,62 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,245 +0,0 @@
-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 typeArgs the type arguments of the move call, such as `['0x2::sui::SUI']`
-   */
-  moveCall(
-    target: string,
-    args: (SuiTxArg | SuiVecTxArg)[] = [],
-    typeArgs: 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: typeArgs,
-    });
-  }
-
-  //======== 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;
-  }
-}