@0xobelisk/sui-client 0.5.3 → 0.5.4

package/src/libs/suiTxBuilder/index.ts

@@ -1,24 +1,36 @@
-import {
-  TransactionBlock,
-  SUI_SYSTEM_STATE_OBJECT_ID,
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { SUI_SYSTEM_STATE_OBJECT_ID } from '@mysten/sui.js/utils';
+import { convertArgs, convertAddressArg, convertObjArg } from './util';
+import type { SuiClient, SuiObjectRef } from '@mysten/sui.js/client';
+import type { TransactionObjectArgument } from '@mysten/sui.js/transactions';
+import type {
   TransactionExpiration,
-  SuiObjectRef,
   SharedObjectRef,
-  JsonRpcProvider,
-  TransactionType,
-  Transactions,
+} from '@mysten/sui.js/bcs';
+import type { Keypair } from '@mysten/sui.js/cryptography';
+import type {
   ObjectCallArg,
-} from '@mysten/sui.js';
-import { convertArgs } from './util';
-import type { SuiTxArg, SuiObjectArg, SuiVecTxArg } from '../../types';
+  TransactionType,
+  SuiTxArg,
+  SuiAddressArg,
+  SuiObjectArg,
+  SuiVecTxArg,
+} from 'src/types';
 
 export class SuiTxBlock {
   public txBlock: TransactionBlock;
+
   constructor(transaction?: TransactionBlock) {
     this.txBlock = new TransactionBlock(transaction);
   }
 
-  //======== override methods of TransactionBlock ============
+  /* Directly wrap methods and properties of TransactionBlock */
+  get gas() {
+    return this.txBlock.gas;
+  }
+  get blockData() {
+    return this.txBlock.blockData;
+  }
 
   address(value: string) {
     return this.txBlock.pure(value, 'address');
@@ -56,71 +68,97 @@ export class SuiTxBlock {
   setGasPayment(payments: SuiObjectRef[]) {
     return this.txBlock.setGasPayment(payments);
   }
-
-  add(transaction: TransactionType) {
-    return this.txBlock.add(transaction);
-  }
   serialize() {
     return this.txBlock.serialize();
   }
+  sign(params: {
+    signer: Keypair;
+    client?: SuiClient;
+    onlyTransactionKind?: boolean;
+  }) {
+    return this.txBlock.sign(params);
+  }
   build(
     params: {
-      provider?: JsonRpcProvider;
+      client?: SuiClient;
       onlyTransactionKind?: boolean;
     } = {}
   ) {
     return this.txBlock.build(params);
   }
-  getDigest({ provider }: { provider?: JsonRpcProvider } = {}) {
-    return this.txBlock.getDigest({ provider });
+  getDigest(params: { client?: SuiClient } = {}) {
+    return this.txBlock.getDigest(params);
+  }
+  add(...args: TransactionType) {
+    return this.txBlock.add(...args);
+  }
+  publish({
+    modules,
+    dependencies,
+  }: {
+    modules: number[][] | string[];
+    dependencies: string[];
+  }) {
+    return this.txBlock.publish({ modules, dependencies });
+  }
+  upgrade({
+    modules,
+    dependencies,
+    packageId,
+    ticket,
+  }: {
+    modules: number[][] | string[];
+    dependencies: string[];
+    packageId: string;
+    ticket: TransactionObjectArgument | string;
+  }) {
+    return this.txBlock.upgrade({ modules, dependencies, packageId, ticket });
+  }
+  makeMoveVec({
+    objects,
+    type,
+  }: {
+    objects: (TransactionObjectArgument | string)[];
+    type?: string;
+  }) {
+    return this.txBlock.makeMoveVec({ objects, type });
   }
 
-  get gas() {
-    return this.txBlock.gas;
-  }
-  get blockData() {
-    return this.txBlock.blockData;
-  }
+  /* Override methods of TransactionBlock */
 
-  transferObjects(objects: SuiObjectArg[], recipient: string) {
-    const tx = this.txBlock;
-    tx.transferObjects(convertArgs(this.txBlock, objects), tx.pure(recipient));
-    return this;
+  transferObjects(objects: SuiObjectArg[], address: SuiAddressArg) {
+    return this.txBlock.transferObjects(
+      objects.map((object) => convertObjArg(this.txBlock, object)),
+      convertAddressArg(this.txBlock, address)
+    );
   }
-  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))
+
+  splitCoins(coin: SuiObjectArg, amounts: SuiTxArg[]) {
+    const res = this.txBlock.splitCoins(
+      convertObjArg(this.txBlock, coin),
+      convertArgs(this.txBlock, amounts)
     );
     return amounts.map((_, i) => res[i]);
   }
+
   mergeCoins(destination: SuiObjectArg, sources: SuiObjectArg[]) {
-    const destinationObject = convertArgs(this.txBlock, [destination])[0];
-    const sourceObjects = convertArgs(this.txBlock, sources);
+    const destinationObject = convertObjArg(this.txBlock, destination);
+    const sourceObjects = sources.map((source) =>
+      convertObjArg(this.txBlock, source)
+    );
     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']`
+   * @param typeArgs the type arguments of the move call, such as `['0x2::sui::SUI']`
    */
   moveCall(
     target: string,
     args: (SuiTxArg | SuiVecTxArg)[] = [],
-    typeArguments: string[] = []
+    typeArgs: string[] = []
   ) {
     // a regex for pattern `${string}::${string}::${string}`
     const regex =
@@ -131,76 +169,77 @@ export class SuiTxBlock {
         'Invalid target format. Expected `${string}::${string}::${string}`'
       );
     const convertedArgs = convertArgs(this.txBlock, args);
-    const tx = this.txBlock;
-    return tx.moveCall({
+    return this.txBlock.moveCall({
       target: target as `${string}::${string}::${string}`,
       arguments: convertedArgs,
-      typeArguments,
+      typeArguments: typeArgs,
     });
   }
 
-  //======== enhance methods ============
-  transferSuiToMany(recipients: string[], amounts: number[]) {
+  /* Enhance methods of TransactionBlock */
+
+  transferSuiToMany(recipients: SuiAddressArg[], amounts: SuiTxArg[]) {
     // 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))
+    const coins = this.txBlock.splitCoins(
+      this.txBlock.gas,
+      convertArgs(this.txBlock, amounts)
     );
-    recipients.forEach((recipient, index) => {
-      tx.transferObjects([coins[index]], tx.pure(recipient));
+    const recipientObjects = recipients.map((recipient) =>
+      convertAddressArg(this.txBlock, recipient)
+    );
+    recipientObjects.forEach((address, index) => {
+      this.txBlock.transferObjects([coins[index]], address);
     });
     return this;
   }
 
-  transferSui(recipient: string, amount: number) {
-    return this.transferSuiToMany([recipient], [amount]);
+  transferSui(address: SuiAddressArg, amount: SuiTxArg) {
+    return this.transferSuiToMany([address], [amount]);
   }
 
-  takeAmountFromCoins(coins: SuiObjectArg[], amount: number) {
-    const tx = this.txBlock;
-    const coinObjects = convertArgs(this.txBlock, coins);
+  takeAmountFromCoins(coins: SuiObjectArg[], amount: SuiTxArg) {
+    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
-      tx.mergeCoins(mergedCoin, coinObjects.slice(1));
+      this.txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const [sendCoin] = tx.splitCoins(mergedCoin, [tx.pure(amount)]);
+    const [sendCoin] = this.txBlock.splitCoins(
+      mergedCoin,
+      convertArgs(this.txBlock, [amount])
+    );
     return [sendCoin, mergedCoin];
   }
 
-  splitSUIFromGas(amounts: number[]) {
-    const tx = this.txBlock;
-    return tx.splitCoins(
-      tx.gas,
-      amounts.map((m) => tx.pure(m))
+  splitSUIFromGas(amounts: SuiTxArg[]) {
+    return this.txBlock.splitCoins(
+      this.txBlock.gas,
+      convertArgs(this.txBlock, amounts)
     );
   }
 
-  splitMultiCoins(coins: SuiObjectArg[], amounts: number[]) {
-    const tx = this.txBlock;
-    const coinObjects = convertArgs(this.txBlock, coins);
+  splitMultiCoins(coins: SuiObjectArg[], amounts: SuiTxArg[]) {
+    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
-      tx.mergeCoins(mergedCoin, coinObjects.slice(1));
+      this.txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const splitedCoins = tx.splitCoins(
+    const splitedCoins = this.txBlock.splitCoins(
       mergedCoin,
-      amounts.map((m) => tx.pure(m))
+      convertArgs(this.txBlock, amounts)
     );
     return { splitedCoins, mergedCoin };
   }
 
   transferCoinToMany(
-    inputCoins: SuiObjectArg[],
-    sender: string,
-    recipients: string[],
-    amounts: number[]
+    coins: SuiObjectArg[],
+    sender: SuiAddressArg,
+    recipients: SuiAddressArg[],
+    amounts: SuiTxArg[]
   ) {
     // require recipients.length === amounts.length
     if (recipients.length !== amounts.length) {
@@ -208,38 +247,45 @@ export class SuiTxBlock {
         'transferSuiToMany: recipients.length !== amounts.length'
       );
     }
-    const tx = this.txBlock;
+    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
     const { splitedCoins, mergedCoin } = this.splitMultiCoins(
-      inputCoins,
+      coinObjects,
       amounts
     );
-    recipients.forEach((recipient, index) => {
-      tx.transferObjects([splitedCoins[index]], tx.pure(recipient));
+    const recipientObjects = recipients.map((recipient) =>
+      convertAddressArg(this.txBlock, recipient)
+    );
+    recipientObjects.forEach((address, index) => {
+      this.txBlock.transferObjects([splitedCoins[index]], address);
     });
-    tx.transferObjects([mergedCoin], tx.pure(sender));
+    this.txBlock.transferObjects(
+      [mergedCoin],
+      convertAddressArg(this.txBlock, sender)
+    );
     return this;
   }
 
   transferCoin(
-    inputCoins: SuiObjectArg[],
-    sender: string,
-    recipient: string,
-    amount: number
+    coins: SuiObjectArg[],
+    sender: SuiAddressArg,
+    recipient: SuiAddressArg,
+    amount: SuiTxArg
   ) {
-    return this.transferCoinToMany(inputCoins, sender, [recipient], [amount]);
+    return this.transferCoinToMany(coins, sender, [recipient], [amount]);
   }
 
-  stakeSui(amount: number, validatorAddr: string) {
-    const tx = this.txBlock;
-    const [stakeCoin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
-    tx.moveCall({
+  stakeSui(amount: SuiTxArg, validatorAddr: SuiAddressArg) {
+    const [stakeCoin] = this.txBlock.splitCoins(
+      this.txBlock.gas,
+      convertArgs(this.txBlock, [amount])
+    );
+    return this.txBlock.moveCall({
       target: '0x3::sui_system::request_add_stake',
-      arguments: [
-        tx.object(SUI_SYSTEM_STATE_OBJECT_ID),
+      arguments: convertArgs(this.txBlock, [
+        SUI_SYSTEM_STATE_OBJECT_ID,
         stakeCoin,
-        tx.pure(validatorAddr),
-      ],
+        this.txBlock.pure(validatorAddr),
+      ]),
     });
-    return tx;
   }
 }

package/src/libs/suiTxBuilder/util.ts

@@ -1,19 +1,36 @@
 import {
   normalizeSuiObjectId,
+  normalizeSuiAddress,
+  isValidSuiObjectId,
+  isValidSuiAddress,
+} from '@mysten/sui.js/utils';
+import { Inputs } from '@mysten/sui.js/transactions';
+import { isPureArg } from '@mysten/sui.js/bcs';
+import { isSerializedBcs } from '@mysten/bcs';
+import type {
   TransactionArgument,
   TransactionBlock,
-} from '@mysten/sui.js';
-import { SuiTxArg, SuiInputTypes } from '../../types';
+  TransactionObjectArgument,
+} from '@mysten/sui.js/transactions';
+import type {
+  SuiInputTypes,
+  SuiObjectArg,
+  SuiAddressArg,
+  SuiTxArg,
+  SuiVecTxArg,
+} from 'src/types';
 
-export const getDefaultSuiInputType = (value: any): SuiInputTypes => {
-  if (typeof value === 'string' && value.startsWith('0x')) {
+export const getDefaultSuiInputType = (
+  value: SuiTxArg
+): SuiInputTypes | undefined => {
+  if (typeof value === 'string' && isValidSuiObjectId(value)) {
     return 'object';
   } else if (typeof value === 'number' || typeof value === 'bigint') {
     return 'u64';
   } else if (typeof value === 'boolean') {
     return 'bool';
   } else {
-    return 'object';
+    return undefined;
   }
 };
 
@@ -22,63 +39,160 @@ export const getDefaultSuiInputType = (value: any): SuiInputTypes => {
  * If type is not provided, we will try to infer the type from the first element
  * By default,
  *
- * string starting with `0x` =====> object id
+ * string is hex and its length equal to 32 =====> 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'
+ * @param type 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | 'signer' | 'object' | string
  */
 export function makeVecParam(
   txBlock: TransactionBlock,
   args: SuiTxArg[],
   type?: SuiInputTypes
-) {
+): TransactionArgument {
   if (args.length === 0)
     throw new Error('Transaction builder error: Empty array is not allowed');
+  // Using first element value as default type
   const defaultSuiType = getDefaultSuiInputType(args[0]);
-  if (type === 'object' || (!type && defaultSuiType === 'object')) {
+  const VECTOR_REGEX = /^vector<(.+)>$/;
+  const STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+
+  type = type || defaultSuiType;
+
+  if (type === 'object') {
     const objects = args.map((arg) =>
-      typeof arg === 'string'
+      typeof arg === 'string' && isValidSuiObjectId(arg)
         ? txBlock.object(normalizeSuiObjectId(arg))
-        : (arg as any)
+        : convertObjArg(txBlock, arg as SuiObjectArg)
     );
     return txBlock.makeMoveVec({ objects });
+  } else if (
+    typeof type === 'string' &&
+    !VECTOR_REGEX.test(type) &&
+    !STRUCT_REGEX.test(type)
+  ) {
+    return txBlock.pure(args, `vector<${type}>`);
   } else {
-    const vecType = type || defaultSuiType;
-    return txBlock.pure(args, `vector<${vecType}>`);
+    const objects = args.map((arg) =>
+      convertObjArg(txBlock, arg as SuiObjectArg)
+    );
+    return txBlock.makeMoveVec({ objects, type });
   }
 }
 
-export function isMoveVecArg(arg: any) {
-  const isFullMoveVecArg =
-    arg && arg.value && Array.isArray(arg.value) && arg.vecType;
-  const isSimpleMoveVecArg = Array.isArray(arg);
-  return isFullMoveVecArg || isSimpleMoveVecArg;
+/**
+ * Check whether it is an valid move vec input.
+ *
+ * @param arg The argument to check.
+ * @returns boolean.
+ */
+export function isMoveVecArg(arg: SuiTxArg | SuiVecTxArg): arg is SuiVecTxArg {
+  if (typeof arg === 'object' && 'vecType' in arg && 'value' in arg) {
+    return true;
+  } else if (Array.isArray(arg)) {
+    return true;
+  }
+  return false;
 }
 
+/**
+ * Convert any valid input into array of TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param args The array of argument to convert.
+ * @returns The converted array of TransactionArgument.
+ */
 export function convertArgs(
   txBlock: TransactionBlock,
-  args: any[]
-): TransactionArgument[] {
+  args: (SuiTxArg | SuiVecTxArg)[]
+) {
   return args.map((arg) => {
-    if (typeof arg === 'string' && arg.startsWith('0x')) {
-      // We always treat string starting with `0x` as object id
+    if (typeof arg === 'string' && isValidSuiObjectId(arg)) {
       return txBlock.object(normalizeSuiObjectId(arg));
+    } else if (
+      typeof arg == 'object' &&
+      !isSerializedBcs(arg) &&
+      !isPureArg(arg) &&
+      !isMoveVecArg(arg)
+    ) {
+      return convertObjArg(txBlock, arg as SuiObjectArg);
     } else if (isMoveVecArg(arg)) {
-      // if it's an array arg, we will convert it to move vec
-      const vecType = arg.vecType || undefined;
+      const vecType = 'vecType' in arg;
       return vecType
-        ? makeVecParam(txBlock, arg.value, vecType)
+        ? makeVecParam(txBlock, arg.value, arg.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
+    } else if (isSerializedBcs(arg)) {
       return arg;
+    } else {
+      return txBlock.pure(arg);
     }
   });
 }
+
+/**
+ * Convert any valid address input into a TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param arg The address argument to convert.
+ * @returns The converted TransactionArgument.
+ */
+export function convertAddressArg(
+  txBlock: TransactionBlock,
+  arg: SuiAddressArg
+) {
+  if (typeof arg === 'string' && isValidSuiAddress(arg)) {
+    return txBlock.pure.address(normalizeSuiAddress(arg));
+  } else if (
+    typeof arg == 'object' &&
+    !isSerializedBcs(arg) &&
+    !isPureArg(arg)
+  ) {
+    return convertObjArg(txBlock, arg as SuiObjectArg);
+  } else if (isPureArg(arg)) {
+    return txBlock.pure(arg);
+  } else {
+    return arg;
+  }
+}
+
+/**
+ * Convert any valid object input into a TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param arg The object argument to convert.
+ * @returns The converted TransactionArgument.
+ */
+export function convertObjArg(
+  txb: TransactionBlock,
+  arg: SuiObjectArg
+): TransactionObjectArgument {
+  if (typeof arg === 'string') {
+    return txb.object(arg);
+  }
+
+  if ('digest' in arg && 'version' in arg && 'objectId' in arg) {
+    return txb.objectRef(arg);
+  }
+
+  if ('objectId' in arg && 'initialSharedVersion' in arg && 'mutable' in arg) {
+    return txb.sharedObjectRef(arg);
+  }
+
+  if ('Object' in arg) {
+    if ('ImmOrOwned' in arg.Object) {
+      return txb.object(Inputs.ObjectRef(arg.Object.ImmOrOwned));
+    } else if ('Shared' in arg.Object) {
+      return txb.object(Inputs.SharedObjectRef(arg.Object.Shared));
+    } else {
+      throw new Error('Invalid argument type');
+    }
+  }
+
+  if ('kind' in arg) {
+    return arg;
+  }
+
+  throw new Error('Invalid argument type');
+}

package/src/metadata/index.ts

@@ -1,5 +1,7 @@
-import { SuiMoveNormalizedModules } from '@mysten/sui.js';
-import { SuiInteractor, getDefaultConnection } from '../libs/suiInteractor';
+import { SuiMoveNormalizedModules } from '@mysten/sui.js/client';
+import { getFullnodeUrl } from '@mysten/sui.js/client';
+
+import { SuiInteractor } from '../libs/suiInteractor';
 
 import { NetworkType } from '../types';
 
@@ -8,7 +10,7 @@ export async function loadMetadata(
   packageId: string
 ) {
   // Init the rpc provider
-  const fullnodeUrls = [getDefaultConnection(networkType).fullnode];
+  const fullnodeUrls = [getFullnodeUrl(networkType)];
   const suiInteractor = new SuiInteractor(fullnodeUrls);
   if (packageId !== undefined) {
     const jsonData = await suiInteractor.getNormalizedMoveModulesByPackage(