@0xobelisk/client 0.0.1

package/src/libs/suiRpcProvider/index.ts

@@ -0,0 +1,114 @@
+import {
+  Connection,
+  JsonRpcProvider,
+  getObjectType,
+  getObjectId,
+  getObjectFields,
+  getObjectDisplay,
+  getObjectVersion,
+} from '@mysten/sui.js';
+import { requestFaucet } from './faucet';
+import { getDefaultNetworkParams } from './defaultChainConfigs';
+import type { ObjectData, SuiRpcProviderParams } from './types';
+
+export class SuiRpcProvider {
+  public fullnodeUrl: string;
+  public faucetUrl?: string;
+  public provider: JsonRpcProvider;
+  /**
+   *
+   * @param networkType, 'testnet' | 'mainnet' | 'devnet' | 'localnet', default is 'devnet'
+   * @param fullnodeUrl, the fullnode url, default is the preconfig fullnode url for the given network type
+   * @param faucetUrl, the faucet url, default is the preconfig faucet url for the given network type
+   */
+  constructor({
+    fullnodeUrl,
+    faucetUrl,
+    networkType,
+  }: SuiRpcProviderParams = {}) {
+    // Get the default fullnode url and faucet url for the given network type, default is 'testnet'
+    const defaultNetworkParams = getDefaultNetworkParams(
+      networkType || 'devnet'
+    );
+    // Set fullnodeUrl and faucetUrl, if they are not provided, use the default value.
+    this.fullnodeUrl = fullnodeUrl || defaultNetworkParams.fullnode;
+    this.faucetUrl = faucetUrl || defaultNetworkParams.faucet;
+
+    // Init the provider
+    const connection = new Connection({
+      fullnode: this.fullnodeUrl,
+      faucet: this.faucetUrl,
+    });
+    this.provider = new JsonRpcProvider(connection);
+  }
+
+  /**
+   * Request some SUI from faucet
+   * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
+   */
+  async requestFaucet(addr: string) {
+    return requestFaucet(addr, this.provider);
+  }
+
+  async getBalance(addr: string, coinType?: string) {
+    return this.provider.getBalance({ owner: addr, coinType });
+  }
+
+  async getObjects(ids: string[]) {
+    const options = { showContent: true, showDisplay: true, showType: true };
+    const objects = await this.provider.multiGetObjects({ ids, options });
+    const parsedObjects = objects.map((object) => {
+      const objectId = getObjectId(object);
+      const objectType = getObjectType(object);
+      const objectVersion = getObjectVersion(object);
+      const objectFields = getObjectFields(object);
+      const objectDisplay = getObjectDisplay(object);
+      return {
+        objectId,
+        objectType,
+        objectVersion,
+        objectFields,
+        objectDisplay,
+      };
+    });
+    return parsedObjects as ObjectData[];
+  }
+
+  /**
+   * @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 coins = await this.provider.getCoins({ owner: addr, coinType });
+    const selectedCoins: {
+      objectId: string;
+      digest: string;
+      version: string;
+    }[] = [];
+    let totalAmount = 0;
+    // 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;
+      }
+    }
+
+    if (!selectedCoins.length) {
+      throw new Error('No valid coins found for the transaction.');
+    }
+    return selectedCoins;
+  }
+}

package/src/libs/suiRpcProvider/types.ts

@@ -0,0 +1,17 @@
+import { DisplayFieldsResponse, ObjectContentFields } from '@mysten/sui.js';
+
+export type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+
+export type ObjectData = {
+  objectId: string;
+  objectType: string;
+  objectVersion: number;
+  objectDisplay: DisplayFieldsResponse;
+  objectFields: ObjectContentFields;
+};
+
+export type SuiRpcProviderParams = {
+  fullnodeUrl?: string;
+  faucetUrl?: string;
+  networkType?: NetworkType;
+};

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 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;
+  }
+}

package/src/libs/suiTxBuilder/types.ts

@@ -0,0 +1,32 @@
+import {
+  SharedObjectRef,
+  SuiObjectRef,
+  TransactionArgument,
+} from '@mysten/sui.js';
+
+export type SuiTxArg = TransactionArgument | string | number | bigint | boolean;
+
+export type SuiObjectArg =
+  | SharedObjectRef
+  | SuiObjectRef
+  | string
+  | 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/src/libs/suiTxBuilder/util.ts

@@ -0,0 +1,84 @@
+import {
+  normalizeSuiObjectId,
+  TransactionArgument,
+  TransactionBlock,
+} from '@mysten/sui.js';
+import { SuiTxArg, SuiInputTypes } from './types';
+
+export const getDefaultSuiInputType = (value: any): SuiInputTypes => {
+  if (typeof value === 'string' && value.startsWith('0x')) {
+    return 'object';
+  } else if (typeof value === 'number' || typeof value === 'bigint') {
+    return 'u64';
+  } else if (typeof value === 'boolean') {
+    return 'bool';
+  } else {
+    return 'object';
+  }
+};
+
+/**
+ * Since we know the elements in the array are the same type
+ * If type is not provided, we will try to infer the type from the first element
+ * By default,
+ *
+ * string starting with `0x` =====> object id
+ * number, bigint ====> u64
+ * boolean =====> bool
+ *
+ *
+ * If type is provided, we will use the type to convert the array
+ * @param args
+ * @param type 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | 'object'
+ */
+export function makeVecParam(
+  txBlock: TransactionBlock,
+  args: SuiTxArg[],
+  type?: SuiInputTypes
+) {
+  if (args.length === 0)
+    throw new Error('Transaction builder error: Empty array is not allowed');
+  const defaultSuiType = getDefaultSuiInputType(args[0]);
+  if (type === 'object' || (!type && defaultSuiType === 'object')) {
+    const objects = args.map((arg) =>
+      typeof arg === 'string'
+        ? txBlock.object(normalizeSuiObjectId(arg))
+        : (arg as any)
+    );
+    return txBlock.makeMoveVec({ objects });
+  } else {
+    const vecType = type || defaultSuiType;
+    return txBlock.pure(args, `vector<${vecType}>`);
+  }
+}
+
+export function isMoveVecArg(arg: any) {
+  const isFullMoveVecArg =
+    arg && arg.value && Array.isArray(arg.value) && arg.vecType;
+  const isSimpleMoveVecArg = Array.isArray(arg);
+  return isFullMoveVecArg || isSimpleMoveVecArg;
+}
+
+export function convertArgs(
+  txBlock: TransactionBlock,
+  args: any[]
+): TransactionArgument[] {
+  return args.map((arg) => {
+    if (typeof arg === 'string' && arg.startsWith('0x')) {
+      // We always treat string starting with `0x` as object id
+      return txBlock.object(normalizeSuiObjectId(arg));
+    } else if (isMoveVecArg(arg)) {
+      // if it's an array arg, we will convert it to move vec
+      const vecType = arg.vecType || undefined;
+      return vecType
+        ? makeVecParam(txBlock, arg.value, vecType)
+        : makeVecParam(txBlock, arg);
+    } else if (typeof arg !== 'object') {
+      // Other basic types such as string, number, boolean are converted to pure value
+      return txBlock.pure(arg);
+    } else {
+      // We do nothing, because it's most likely already a move value
+      return arg;
+    }
+  });
+}