@0xobelisk/sui-client 0.5.17 → 0.5.19

package/src/libs/suiTxBuilder/index.ts

@@ -1,13 +1,13 @@
-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 { Transaction } from '@mysten/sui/transactions';
+import { SUI_SYSTEM_STATE_OBJECT_ID } from '@mysten/sui/utils';
+import type { SuiClient, SuiObjectRef } from '@mysten/sui/client';
 import type {
-  TransactionExpiration,
-  SharedObjectRef,
-} from '@mysten/sui.js/bcs';
-import type { Keypair } from '@mysten/sui.js/cryptography';
+  TransactionObjectArgument,
+  TransactionObjectInput,
+} from '@mysten/sui/transactions';
+import type { Keypair } from '@mysten/sui/cryptography';
+import { SerializedBcs } from '@mysten/bcs';
+
 import type {
   ObjectCallArg,
   TransactionType,
@@ -15,68 +15,91 @@ import type {
   SuiAddressArg,
   SuiObjectArg,
   SuiVecTxArg,
+  SuiAmountsArg,
 } from '../../types';
 
-export class SuiTxBlock {
-  public txBlock: TransactionBlock;
+import type { bcs } from '@mysten/sui/bcs';
+import {
+  convertArgs,
+  convertAddressArg,
+  convertObjArg,
+  convertAmounts,
+} from './util';
+export class SuiTx {
+  public tx: Transaction;
 
-  constructor(transaction?: TransactionBlock) {
-    this.txBlock = new TransactionBlock(transaction);
+  constructor(transaction?: Transaction) {
+    if (transaction !== undefined) {
+      this.tx = Transaction.from(transaction);
+    } else {
+      this.tx = new Transaction();
+    }
   }
 
   /* Directly wrap methods and properties of TransactionBlock */
   get gas() {
-    return this.txBlock.gas;
+    return this.tx.gas;
   }
   get blockData() {
-    return this.txBlock.blockData;
+    return this.tx.blockData;
+  }
+
+  autoPure(value: SuiTxArg, type?: string) {
+    if (type === undefined) {
+      return convertArgs(this.tx, [value]);
+    }
+
+    return;
   }
 
   address(value: string) {
-    return this.txBlock.pure(value, 'address');
+    return this.tx.pure.address(value);
   }
-  pure(value: unknown, type?: string) {
-    return this.txBlock.pure(value, type);
+  get pure() {
+    return this.tx.pure.bind(this.tx);
   }
-  object(value: string | ObjectCallArg) {
-    return this.txBlock.object(value);
+  object(value: string | TransactionObjectInput) {
+    return this.tx.object(value);
   }
   objectRef(ref: SuiObjectRef) {
-    return this.txBlock.objectRef(ref);
+    return this.tx.objectRef(ref);
   }
-  sharedObjectRef(ref: SharedObjectRef) {
-    return this.txBlock.sharedObjectRef(ref);
+  sharedObjectRef(ref: typeof bcs.SharedObjectRef.$inferType) {
+    return this.tx.sharedObjectRef(ref);
   }
   setSender(sender: string) {
-    return this.txBlock.setSender(sender);
+    return this.tx.setSender(sender);
   }
   setSenderIfNotSet(sender: string) {
-    return this.txBlock.setSenderIfNotSet(sender);
+    return this.tx.setSenderIfNotSet(sender);
   }
-  setExpiration(expiration?: TransactionExpiration) {
-    return this.txBlock.setExpiration(expiration);
+  setExpiration(expiration?: Parameters<typeof this.tx.setExpiration>[0]) {
+    return this.tx.setExpiration(expiration);
   }
   setGasPrice(price: number | bigint) {
-    return this.txBlock.setGasPrice(price);
+    return this.tx.setGasPrice(price);
   }
   setGasBudget(budget: number | bigint) {
-    return this.txBlock.setGasBudget(budget);
+    return this.tx.setGasBudget(budget);
   }
   setGasOwner(owner: string) {
-    return this.txBlock.setGasOwner(owner);
+    return this.tx.setGasOwner(owner);
   }
   setGasPayment(payments: SuiObjectRef[]) {
-    return this.txBlock.setGasPayment(payments);
+    return this.tx.setGasPayment(payments);
   }
   serialize() {
-    return this.txBlock.serialize();
+    return this.tx.serialize();
+  }
+  toJSON() {
+    return this.tx.toJSON();
   }
   sign(params: {
     signer: Keypair;
     client?: SuiClient;
     onlyTransactionKind?: boolean;
   }) {
-    return this.txBlock.sign(params);
+    return this.tx.sign(params);
   }
   build(
     params: {
@@ -84,13 +107,13 @@ export class SuiTxBlock {
       onlyTransactionKind?: boolean;
     } = {}
   ) {
-    return this.txBlock.build(params);
+    return this.tx.build(params);
   }
   getDigest(params: { client?: SuiClient } = {}) {
-    return this.txBlock.getDigest(params);
+    return this.tx.getDigest(params);
   }
-  add(...args: TransactionType) {
-    return this.txBlock.add(...args);
+  add(...args: Parameters<typeof this.tx.add>) {
+    return this.tx.add(...args);
   }
   publish({
     modules,
@@ -99,54 +122,38 @@ export class SuiTxBlock {
     modules: number[][] | string[];
     dependencies: string[];
   }) {
-    return this.txBlock.publish({ modules, dependencies });
+    return this.tx.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 });
+  upgrade(...args: Parameters<typeof this.tx.upgrade>) {
+    return this.tx.upgrade(...args);
   }
-  makeMoveVec({
-    objects,
-    type,
-  }: {
-    objects: (TransactionObjectArgument | string)[];
-    type?: string;
-  }) {
-    return this.txBlock.makeMoveVec({ objects, type });
+  makeMoveVec(...args: Parameters<typeof this.tx.makeMoveVec>) {
+    return this.tx.makeMoveVec(...args);
   }
 
   /* Override methods of TransactionBlock */
 
   transferObjects(objects: SuiObjectArg[], address: SuiAddressArg) {
-    return this.txBlock.transferObjects(
-      objects.map((object) => convertObjArg(this.txBlock, object)),
-      convertAddressArg(this.txBlock, address)
+    return this.tx.transferObjects(
+      objects.map((object) => convertObjArg(this.tx, object)),
+      convertAddressArg(this.tx, address)
     );
   }
 
   splitCoins(coin: SuiObjectArg, amounts: SuiTxArg[]) {
-    const res = this.txBlock.splitCoins(
-      convertObjArg(this.txBlock, coin),
-      convertArgs(this.txBlock, amounts)
+    const res = this.tx.splitCoins(
+      convertObjArg(this.tx, coin),
+      convertArgs(this.tx, amounts)
     );
     return amounts.map((_, i) => res[i]);
   }
 
   mergeCoins(destination: SuiObjectArg, sources: SuiObjectArg[]) {
-    const destinationObject = convertObjArg(this.txBlock, destination);
+    const destinationObject = convertObjArg(this.tx, destination);
     const sourceObjects = sources.map((source) =>
-      convertObjArg(this.txBlock, source)
+      convertObjArg(this.tx, source)
     );
-    return this.txBlock.mergeCoins(destinationObject, sourceObjects);
+    return this.tx.mergeCoins(destinationObject, sourceObjects);
   }
 
   /**
@@ -168,8 +175,8 @@ export class SuiTxBlock {
       throw new Error(
         'Invalid target format. Expected `${string}::${string}::${string}`'
       );
-    const convertedArgs = convertArgs(this.txBlock, args);
-    return this.txBlock.moveCall({
+    const convertedArgs = convertArgs(this.tx, args);
+    return this.tx.moveCall({
       target: target as `${string}::${string}::${string}`,
       arguments: convertedArgs,
       typeArguments: typeArgs,
@@ -178,59 +185,67 @@ export class SuiTxBlock {
 
   /* Enhance methods of TransactionBlock */
 
-  transferSuiToMany(recipients: SuiAddressArg[], amounts: SuiTxArg[]) {
+  transferSuiToMany(
+    recipients: SuiAddressArg[],
+    amounts: (SuiTxArg | number | bigint)[]
+  ) {
     // require recipients.length === amounts.length
     if (recipients.length !== amounts.length) {
       throw new Error(
         'transferSuiToMany: recipients.length !== amounts.length'
       );
     }
-    const coins = this.txBlock.splitCoins(
-      this.txBlock.gas,
-      convertArgs(this.txBlock, amounts)
+    const coins = this.tx.splitCoins(
+      this.tx.gas,
+      amounts.map((amount) =>
+        typeof amount === 'number' || typeof amount === 'bigint'
+          ? amount
+          : convertArgs(this.tx, [amount])[0]
+      )
     );
     const recipientObjects = recipients.map((recipient) =>
-      convertAddressArg(this.txBlock, recipient)
+      convertAddressArg(this.tx, recipient)
     );
     recipientObjects.forEach((address, index) => {
-      this.txBlock.transferObjects([coins[index]], address);
+      this.tx.transferObjects([coins[index]], address);
     });
     return this;
   }
 
-  transferSui(address: SuiAddressArg, amount: SuiTxArg) {
+  transferSui(address: SuiAddressArg, amount: SuiTxArg | number | bigint) {
     return this.transferSuiToMany([address], [amount]);
   }
 
-  takeAmountFromCoins(coins: SuiObjectArg[], amount: SuiTxArg) {
-    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
+  takeAmountFromCoins(
+    coins: SuiObjectArg[],
+    amount: SuiTxArg | number | bigint
+  ) {
+    const coinObjects = coins.map((coin) => convertObjArg(this.tx, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
-      this.txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
+      this.tx.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const [sendCoin] = this.txBlock.splitCoins(
-      mergedCoin,
-      convertArgs(this.txBlock, [amount])
-    );
+    const [sendCoin] = this.tx.splitCoins(mergedCoin, [
+      typeof amount === 'number' || typeof amount === 'bigint'
+        ? amount
+        : convertArgs(this.tx, [amount])[0],
+    ]);
     return [sendCoin, mergedCoin];
   }
 
   splitSUIFromGas(amounts: SuiTxArg[]) {
-    return this.txBlock.splitCoins(
-      this.txBlock.gas,
-      convertArgs(this.txBlock, amounts)
-    );
+    return this.tx.splitCoins(this.tx.gas, convertArgs(this.tx, amounts));
   }
 
-  splitMultiCoins(coins: SuiObjectArg[], amounts: SuiTxArg[]) {
-    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
+  splitMultiCoins(coins: SuiObjectArg[], amounts: SuiAmountsArg[]) {
+    const coinObjects = coins.map((coin) => convertObjArg(this.tx, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
-      this.txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
+      this.tx.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const splitedCoins = this.txBlock.splitCoins(
+    const splitedCoins = this.tx.splitCoins(
       mergedCoin,
-      convertArgs(this.txBlock, amounts)
+      convertAmounts(this.tx, amounts)
     );
     return { splitedCoins, mergedCoin };
   }
@@ -239,7 +254,7 @@ export class SuiTxBlock {
     coins: SuiObjectArg[],
     sender: SuiAddressArg,
     recipients: SuiAddressArg[],
-    amounts: SuiTxArg[]
+    amounts: SuiAmountsArg[]
   ) {
     // require recipients.length === amounts.length
     if (recipients.length !== amounts.length) {
@@ -247,21 +262,18 @@ export class SuiTxBlock {
         'transferSuiToMany: recipients.length !== amounts.length'
       );
     }
-    const coinObjects = coins.map((coin) => convertObjArg(this.txBlock, coin));
+    const coinObjects = coins.map((coin) => convertObjArg(this.tx, coin));
     const { splitedCoins, mergedCoin } = this.splitMultiCoins(
       coinObjects,
       amounts
     );
     const recipientObjects = recipients.map((recipient) =>
-      convertAddressArg(this.txBlock, recipient)
+      convertAddressArg(this.tx, recipient)
     );
     recipientObjects.forEach((address, index) => {
-      this.txBlock.transferObjects([splitedCoins[index]], address);
+      this.tx.transferObjects([splitedCoins[index]], address);
     });
-    this.txBlock.transferObjects(
-      [mergedCoin],
-      convertAddressArg(this.txBlock, sender)
-    );
+    this.tx.transferObjects([mergedCoin], convertAddressArg(this.tx, sender));
     return this;
   }
 
@@ -274,17 +286,17 @@ export class SuiTxBlock {
     return this.transferCoinToMany(coins, sender, [recipient], [amount]);
   }
 
-  stakeSui(amount: SuiTxArg, validatorAddr: SuiAddressArg) {
-    const [stakeCoin] = this.txBlock.splitCoins(
-      this.txBlock.gas,
-      convertArgs(this.txBlock, [amount])
+  stakeSui(amount: SuiTxArg | number | bigint, validatorAddr: SuiAddressArg) {
+    const [stakeCoin] = this.tx.splitCoins(
+      this.tx.gas,
+      convertAmounts(this.tx, [amount])
     );
-    return this.txBlock.moveCall({
+    return this.tx.moveCall({
       target: '0x3::sui_system::request_add_stake',
-      arguments: convertArgs(this.txBlock, [
-        SUI_SYSTEM_STATE_OBJECT_ID,
+      arguments: convertArgs(this.tx, [
+        this.tx.object(SUI_SYSTEM_STATE_OBJECT_ID),
         stakeCoin,
-        this.txBlock.pure(validatorAddr),
+        convertAddressArg(this.tx, validatorAddr),
       ]),
     });
   }

package/src/libs/suiTxBuilder/util.ts

@@ -3,26 +3,25 @@ import {
   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';
+} from '@mysten/sui/utils';
+import { Inputs, getPureBcsSchema } from '@mysten/sui/transactions';
+import { SerializedBcs, bcs, isSerializedBcs } from '@mysten/bcs';
 import type {
   TransactionArgument,
-  TransactionBlock,
+  Transaction,
   TransactionObjectArgument,
-} from '@mysten/sui.js/transactions';
+} from '@mysten/sui/transactions';
 import type {
-  SuiInputTypes,
   SuiObjectArg,
   SuiAddressArg,
   SuiTxArg,
   SuiVecTxArg,
-} from '../../types';
+  SuiInputTypes,
+} from 'src/types';
 
 export const getDefaultSuiInputType = (
   value: SuiTxArg
-): SuiInputTypes | undefined => {
+): 'u64' | 'bool' | 'object' | undefined => {
   if (typeof value === 'string' && isValidSuiObjectId(value)) {
     return 'object';
   } else if (typeof value === 'number' || typeof value === 'bigint') {
@@ -48,7 +47,7 @@ export const getDefaultSuiInputType = (
  * @param type 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | 'signer' | 'object' | string
  */
 export function makeVecParam(
-  txBlock: TransactionBlock,
+  txBlock: Transaction,
   args: SuiTxArg[],
   type?: SuiInputTypes
 ): TransactionArgument {
@@ -62,23 +61,24 @@ export function makeVecParam(
   type = type || defaultSuiType;
 
   if (type === 'object') {
-    const objects = args.map((arg) =>
+    const elements = args.map((arg) =>
       typeof arg === 'string' && isValidSuiObjectId(arg)
         ? txBlock.object(normalizeSuiObjectId(arg))
         : convertObjArg(txBlock, arg as SuiObjectArg)
     );
-    return txBlock.makeMoveVec({ objects });
+    return txBlock.makeMoveVec({ elements });
   } else if (
     typeof type === 'string' &&
     !VECTOR_REGEX.test(type) &&
     !STRUCT_REGEX.test(type)
   ) {
-    return txBlock.pure(args, `vector<${type}>`);
+    const bcsSchema = getPureBcsSchema(type)!;
+    return txBlock.pure(bcs.vector(bcsSchema).serialize(args));
   } else {
-    const objects = args.map((arg) =>
+    const elements = args.map((arg) =>
       convertObjArg(txBlock, arg as SuiObjectArg)
     );
-    return txBlock.makeMoveVec({ objects, type });
+    return txBlock.makeMoveVec({ elements, type });
   }
 }
 
@@ -105,29 +105,22 @@ export function isMoveVecArg(arg: SuiTxArg | SuiVecTxArg): arg is SuiVecTxArg {
  * @returns The converted array of TransactionArgument.
  */
 export function convertArgs(
-  txBlock: TransactionBlock,
+  txBlock: Transaction,
   args: (SuiTxArg | SuiVecTxArg)[]
-) {
+): TransactionArgument[] {
   return args.map((arg) => {
-    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 (arg instanceof SerializedBcs || isSerializedBcs(arg)) {
+      return txBlock.pure(arg);
+    }
+
+    if (isMoveVecArg(arg)) {
       const vecType = 'vecType' in arg;
       return vecType
         ? makeVecParam(txBlock, arg.value, arg.vecType)
         : makeVecParam(txBlock, arg);
-    } else if (isSerializedBcs(arg)) {
-      return arg;
-    } else {
-      return txBlock.pure(arg);
     }
+
+    return arg;
   });
 }
 
@@ -139,21 +132,13 @@ export function convertArgs(
  * @returns The converted TransactionArgument.
  */
 export function convertAddressArg(
-  txBlock: TransactionBlock,
+  txBlock: Transaction,
   arg: SuiAddressArg
-) {
+): TransactionArgument {
   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;
+    return convertArgs(txBlock, [arg])[0];
   }
 }
 
@@ -165,7 +150,7 @@ export function convertAddressArg(
  * @returns The converted TransactionArgument.
  */
 export function convertObjArg(
-  txb: TransactionBlock,
+  txb: Transaction,
   arg: SuiObjectArg
 ): TransactionObjectArgument {
   if (typeof arg === 'string') {
@@ -181,18 +166,40 @@ export function convertObjArg(
   }
 
   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));
+    if ('ImmOrOwnedObject' in arg.Object) {
+      return txb.object(Inputs.ObjectRef(arg.Object.ImmOrOwnedObject));
+    } else if ('SharedObject' in arg.Object) {
+      return txb.object(Inputs.SharedObjectRef(arg.Object.SharedObject));
     } else {
       throw new Error('Invalid argument type');
     }
   }
 
-  if ('kind' in arg) {
+  if (typeof arg === 'function') {
+    return arg;
+  }
+
+  if (
+    'GasCoin' in arg ||
+    'Input' in arg ||
+    'Result' in arg ||
+    'NestedResult' in arg
+  ) {
     return arg;
   }
 
   throw new Error('Invalid argument type');
 }
+
+export function convertAmounts(
+  txBlock: Transaction,
+  amounts: (SuiTxArg | number | bigint)[]
+): (TransactionArgument | number | bigint)[] {
+  return amounts.map((amount) => {
+    if (typeof amount === 'number' || typeof amount === 'bigint') {
+      return amount;
+    } else {
+      return convertArgs(txBlock, [amount])[0];
+    }
+  });
+}

package/src/metadata/index.ts

@@ -1,8 +1,7 @@
-import { SuiMoveNormalizedModules } from '@mysten/sui.js/client';
-import { getFullnodeUrl } from '@mysten/sui.js/client';
+import { SuiMoveNormalizedModules } from '@mysten/sui/client';
+import { getFullnodeUrl } from '@mysten/sui/client';
 
 import { SuiInteractor } from '../libs/suiInteractor';
-
 import { NetworkType } from '../types';
 
 export async function loadMetadata(