@0xobelisk/sui-client 0.5.18 → 0.5.19

package/dist/obelisk.d.ts

@@ -0,0 +1,140 @@
+/// <reference types="node" />
+import { Transaction } from '@mysten/sui/transactions';
+import type { SuiTransactionBlockResponse, DevInspectResults, SuiMoveNormalizedModules, SuiObjectData } from '@mysten/sui/client';
+import { SuiAccountManager } from './libs/suiAccountManager';
+import { SuiTx } from './libs/suiTxBuilder';
+import { SuiInteractor } from './libs/suiInteractor';
+import { MapMoudleStruct, NetworkType } from './types';
+import { SuiContractFactory } from './libs/suiContractFactory';
+import { SuiMoveMoudleFuncType } from './libs/suiContractFactory/types';
+import { DerivePathParams, FaucetNetworkType, MapMoudleFuncQuery, MapMoudleFuncTx, ObeliskParams, SuiTxArg, SuiVecTxArg } from './types';
+export declare function isUndefined(value?: unknown): value is undefined;
+export declare function withMeta<T extends {
+    meta: SuiMoveMoudleFuncType;
+}>(meta: SuiMoveMoudleFuncType, creator: Omit<T, 'meta'>): T;
+/**
+ * @class Obelisk
+ * @description This class is used to aggregate the tools that used to interact with SUI network.
+ */
+export declare class Obelisk {
+    #private;
+    accountManager: SuiAccountManager;
+    suiInteractor: SuiInteractor;
+    contractFactory: SuiContractFactory;
+    packageId: string | undefined;
+    metadata: SuiMoveNormalizedModules | undefined;
+    /**
+     * Support the following ways to init the ObeliskClient:
+     * 1. mnemonics
+     * 2. secretKey (base64 or hex)
+     * If none of them is provided, will generate a random mnemonics with 24 words.
+     *
+     * @param mnemonics, 12 or 24 mnemonics words, separated by space
+     * @param secretKey, base64 or hex string or bech32, when mnemonics is provided, secretKey will be ignored
+     * @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 packageId
+     */
+    constructor({ mnemonics, secretKey, networkType, fullnodeUrls, packageId, metadata, }?: ObeliskParams);
+    get query(): MapMoudleFuncQuery;
+    get tx(): MapMoudleFuncTx;
+    get struct(): MapMoudleStruct;
+    /**
+     * if derivePathParams is not provided or mnemonics is empty, it will return the keypair.
+     * else:
+     * it will generate signer from the mnemonic with the given derivePathParams.
+     * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
+     */
+    getKeypair(derivePathParams?: DerivePathParams): import("@mysten/sui/dist/cjs/keypairs/ed25519").Ed25519Keypair;
+    /**
+     * @description Switch the current account with the given derivePathParams
+     * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
+     */
+    switchAccount(derivePathParams: DerivePathParams): void;
+    /**
+     * @description Get the address of the account for the given derivePathParams
+     * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
+     */
+    getAddress(derivePathParams?: DerivePathParams): string;
+    currentAddress(): string;
+    getPackageId(): string;
+    getMetadata(): SuiMoveNormalizedModules | undefined;
+    getNetwork(): NetworkType | undefined;
+    /**
+     * Request some SUI from faucet
+     * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
+     */
+    requestFaucet(address?: string, network?: FaucetNetworkType, derivePathParams?: DerivePathParams): Promise<void>;
+    getBalance(coinType?: string, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/client").CoinBalance>;
+    balanceOf(accountAddress?: string, coinType?: string, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/client").CoinBalance>;
+    client(): import("@mysten/sui/client").SuiClient;
+    getObject(objectId: string): Promise<SuiObjectData>;
+    getObjects(objectIds: string[]): Promise<SuiObjectData[]>;
+    signTxn(tx: Uint8Array | Transaction | SuiTx, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/dist/cjs/cryptography").SignatureWithBytes>;
+    signAndSendTxn(tx: Uint8Array | Transaction | SuiTx, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    sendTxn(transactionBlock: Uint8Array | string, signature: string | string[]): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Transfer the given amount of SUI to the recipient
+     * @param recipient
+     * @param amount
+     * @param derivePathParams
+     */
+    transferSui(recipient: string, amount: number, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Transfer to mutliple recipients
+     * @param recipients the recipients addresses
+     * @param amounts the amounts of SUI to transfer to each recipient, the length of amounts should be the same as the length of recipients
+     * @param derivePathParams
+     */
+    transferSuiToMany(recipients: string[], amounts: number[], derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Transfer the given amounts of coin to multiple recipients
+     * @param recipients the list of recipient address
+     * @param amounts the amounts to transfer for each recipient
+     * @param coinType any custom coin type but not SUI
+     * @param derivePathParams the derive path params for the current signer
+     */
+    transferCoinToMany(recipients: string[], amounts: number[], coinType: string, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    transferCoin(recipient: string, amount: number, coinType: string, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    transferObjects(objects: string[], recipient: string, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    moveCall(callParams: {
+        target: string;
+        arguments?: (SuiTxArg | SuiVecTxArg)[];
+        typeArguments?: string[];
+        derivePathParams?: DerivePathParams;
+    }): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Select coins with the given amount and coin type, the total amount is greater than or equal to the given amount
+     * @param amount
+     * @param coinType
+     * @param owner
+     */
+    selectCoinsWithAmount(amount: number, coinType: string, owner?: string): Promise<string[]>;
+    selectObjectsWithType(objectType: string, owner?: string): Promise<string[]>;
+    /**
+     * stake the given amount of SUI to the validator
+     * @param amount the amount of SUI to stake
+     * @param validatorAddr the validator address
+     * @param derivePathParams the derive path params for the current signer
+     */
+    stakeSui(amount: number, validatorAddr: string, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Execute the transaction with on-chain data but without really submitting. Useful for querying the effects of a transaction.
+     * Since the transaction is not submitted, its gas cost is not charged.
+     * @param tx the transaction to execute
+     * @param derivePathParams the derive path params
+     * @returns the effects and events of the transaction, such as object changes, gas cost, event emitted.
+     */
+    inspectTxn(tx: Uint8Array | Transaction | SuiTx, derivePathParams?: DerivePathParams): Promise<DevInspectResults>;
+    getWorld(worldObjectId: string): Promise<SuiObjectData>;
+    listSchemaNames(worldId: string): Promise<any>;
+    getEntity(worldId: string, schemaName: string, entityId?: string): Promise<any[] | undefined>;
+    containEntity(worldId: string, schemaName: string, entityId?: string): Promise<boolean | undefined>;
+    getOwnedObjects(owner: string, cursor?: string, limit?: number): Promise<SuiObjectData[]>;
+    entity_key_from_object(objectId: string): Promise<string | undefined>;
+    entity_key_from_bytes(bytes: Uint8Array | Buffer | string): Promise<string>;
+    entity_key_from_address_with_seed(objectId: string, seed: string): Promise<string | undefined>;
+    entity_key_from_address_with_u256(objectId: string, x: number): Promise<string | undefined>;
+    entity_key_from_u256(x: number): Promise<string>;
+    autoFormatDryValue(value: DevInspectResults): Promise<(string | number | boolean | number[] | null)[] | undefined>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,202 @@
+import type { Infer } from 'superstruct';
+import type { BcsType, SerializedBcs } from '@mysten/bcs';
+import type { TransactionArgument } from '@mysten/sui/transactions';
+import type { Transaction, TransactionObjectArgument, TransactionResult, Argument, Inputs } from '@mysten/sui/transactions';
+import type { SuiMoveNormalizedModules, DevInspectResults, SuiTransactionBlockResponse, DisplayFieldsResponse, SuiMoveNormalizedType, MoveStruct } from '@mysten/sui/client';
+import { SuiMoveMoudleFuncType } from '../libs/suiContractFactory/types';
+export declare const ObjectContentFields: import("superstruct").Struct<Record<string, any>, null>;
+export type ObjectContentFields = Infer<typeof ObjectContentFields>;
+export type ObeliskObjectData = {
+    objectId: string;
+    objectType: string;
+    objectVersion: number;
+    objectDisplay: DisplayFieldsResponse;
+    objectFields: ObjectContentFields;
+};
+export type ObeliskObjectContent = {
+    dataType: 'moveObject';
+    fields: MoveStruct;
+    hasPublicTransfer: boolean;
+    type: string;
+};
+export type ObeliskParams = {
+    mnemonics?: string;
+    secretKey?: string;
+    fullnodeUrls?: string[];
+    faucetUrl?: string;
+    networkType?: NetworkType;
+    packageId?: string;
+    metadata?: SuiMoveNormalizedModules;
+};
+export type SchemaFieldType = {
+    schemas: {
+        type: string;
+        fields: {
+            id: {
+                id: string;
+            };
+            size: string;
+        };
+    };
+};
+export type SchemaValueType = {
+    id: {
+        id: string;
+    };
+    name: string;
+    value: {
+        type: string;
+        fields: SchemaFieldType;
+    };
+};
+export type SchemaContentType = {
+    type: string;
+    fields: SchemaValueType;
+    hasPublicTransfer: boolean;
+    dataType: 'moveObject';
+};
+export interface MessageMeta {
+    readonly meta: SuiMoveMoudleFuncType;
+}
+export interface ContractQuery extends MessageMeta {
+    (tx: Transaction, params: (TransactionArgument | SerializedBcs<any>)[], typeArguments?: string[], isRaw?: boolean): Promise<DevInspectResults | TransactionResult>;
+}
+export interface ContractTx extends MessageMeta {
+    (tx: Transaction, params: (TransactionArgument | SerializedBcs<any>)[], typeArguments?: string[], isRaw?: boolean): Promise<SuiTransactionBlockResponse | TransactionResult>;
+}
+export type MapMessageTx = Record<string, ContractTx>;
+export type MapMessageQuery = Record<string, ContractQuery>;
+export type MapMoudleFuncTx = Record<string, MapMessageTx>;
+export type MapMoudleFuncQuery = Record<string, MapMessageQuery>;
+type MoveStructType = {
+    struct: Record<string, {
+        fields: {
+            type: SuiMoveNormalizedType;
+            name: string;
+        }[];
+        abilities: {
+            abilities: string[];
+        };
+        typeParameters: {
+            constraints: {
+                abilities: string[];
+            };
+            isPhantom: boolean;
+        }[];
+    }>;
+    bcs: BcsType<{
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>;
+};
+export type MapMoudleStruct = Record<string, MoveStructType>;
+export type MapMoudleFuncTest = Record<string, Record<string, string>>;
+export type MapMoudleFuncQueryTest = Record<string, Record<string, string>>;
+export type AccountMangerParams = {
+    mnemonics?: string;
+    secretKey?: string;
+};
+export type DerivePathParams = {
+    accountIndex?: number;
+    isExternal?: boolean;
+    addressIndex?: number;
+};
+export type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+export type FaucetNetworkType = 'testnet' | 'devnet' | 'localnet';
+export type SuiKitParams = {
+    mnemonics?: string;
+    secretKey?: string;
+    fullnodeUrls?: string[];
+    faucetUrl?: string;
+    networkType?: NetworkType;
+};
+export type ObjectData = {
+    objectId: string;
+    objectType: string;
+    objectVersion: number;
+    objectDigest: string;
+    initialSharedVersion?: number;
+    objectDisplay: DisplayFieldsResponse;
+    objectFields: ObjectContentFields;
+};
+type TransactionBlockType = InstanceType<typeof Transaction>;
+export type PureCallArg = {
+    Pure: number[];
+};
+/**
+ * An object argument.
+ */
+type ObjectArg = {
+    ImmOrOwnedObject: SuiObjectRef;
+} | {
+    SharedObject: SharedObjectRef;
+} | {
+    Receiving: SuiObjectRef;
+};
+export type ObjectCallArg = {
+    Object: ObjectArg;
+};
+export type TransactionType = Parameters<TransactionBlockType['add']>;
+export type TransactionPureArgument = Extract<Argument, {
+    $kind: 'Input';
+    type?: 'pure';
+}>;
+export type ObjectFieldType = {
+    id: {
+        id: string;
+    };
+    name: string;
+    value: string;
+};
+export type EntityData = {
+    objectId: string;
+    index: string;
+    key: string;
+};
+type SharedObjectRef = {
+    /** Hex code as string representing the object id */
+    objectId: string;
+    /** The version the object was shared at */
+    initialSharedVersion: number | string;
+    /** Whether reference is mutable */
+    mutable: boolean;
+};
+type SuiObjectRef = {
+    /** Base64 string representing the object digest */
+    objectId: string;
+    /** Object version */
+    version: number | string;
+    /** Hex code as string representing the object id */
+    digest: string;
+};
+export type SuiTxArg = TransactionArgument | SerializedBcs<any>;
+export type SuiAddressArg = Argument | SerializedBcs<any> | string;
+export type SuiAmountsArg = SuiTxArg | number | bigint;
+export type SuiObjectArg = TransactionObjectArgument | string | Parameters<typeof Inputs.ObjectRef>[0] | Parameters<typeof Inputs.SharedObjectRef>[0] | ObjectCallArg;
+export type SuiVecTxArg = {
+    value: SuiTxArg[];
+    vecType: SuiInputTypes;
+} | SuiTxArg[];
+export type DryTxReturnValues = Array<[Uint8Array, string]>;
+/**
+ * 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;
+export type SuiReturnValues = {
+    returnValues: [number[], string][];
+}[];
+export type DynamicFieldContentType = {
+    type: string;
+    fields: Record<string, any>;
+    hasPublicTransfer: boolean;
+    dataType: string;
+};
+export type ObjectContent = {
+    type: string;
+    fields: Record<string, any>;
+    hasPublicTransfer: boolean;
+    dataType: string;
+};
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export declare function capitalizeFirstLetter(input: string): string;
+export declare function normalizeHexAddress(input: string): string | null;
+export declare function numberToAddressHex(num: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-client",
-  "version": "0.5.18",
+  "version": "0.5.19",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -59,9 +59,6 @@
     "tmp": "^0.2.1",
     "valibot": "^0.25.0"
   },
-  "peerDependencies": {
-    "@mysten/sui": "^1.1.2"
-  },
   "devDependencies": {
     "@commitlint/cli": "^18.0.0",
     "@commitlint/config-conventional": "^18.0.0",
@@ -80,7 +77,7 @@
     "tsconfig-paths": "^4.2.0",
     "tsup": "^7.1.0",
     "typedoc": "^0.25.2",
-    "typescript": "^5.0.4"
+    "typescript": "^5.2.2"
   },
   "lint-staged": {
     "**/*.ts": [

package/src/libs/multiSig/client.ts

@@ -1,5 +1,5 @@
 import { MultiSigPublicKey } from '@mysten/sui/multisig';
-import type { PublicKey } from '@mysten/sui/src/cryptography';
+import type { PublicKey } from '@mysten/sui/cryptography';
 import { ed25519PublicKeyFromBase64 } from './publickey';
 
 export type PublicKeyWeightPair = {

package/src/libs/suiAccountManager/index.ts

@@ -1,13 +1,12 @@
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
-import {
-  SUI_PRIVATE_KEY_PREFIX,
-  decodeSuiPrivateKey,
-} from '@mysten/sui/cryptography';
-
 import { getKeyPair } from './keypair';
 import { hexOrBase64ToUint8Array, normalizePrivateKey } from './util';
 import { generateMnemonic } from './crypto';
 import type { AccountMangerParams, DerivePathParams } from 'src/types';
+import {
+  SUI_PRIVATE_KEY_PREFIX,
+  decodeSuiPrivateKey,
+} from '@mysten/sui/cryptography';
 
 export class SuiAccountManager {
   private mnemonics: string;

package/src/libs/suiInteractor/index.ts

@@ -1,2 +1 @@
 export { SuiInteractor } from './suiInteractor';
-// export { getDefaultConnection } from './defaultConfig';

package/src/libs/suiModel/suiOwnedObject.ts

@@ -1,5 +1,5 @@
 import type { SuiTransactionBlockResponse } from '@mysten/sui/client';
-import { bcs } from '@mysten/sui/bcs';
+import type { CallArg } from '@mysten/sui/transactions';
 
 export class SuiOwnedObject {
   public readonly objectId: string;
@@ -21,7 +21,7 @@ export class SuiOwnedObject {
     return !!this.version && !!this.digest;
   }
 
-  asCallArg(): typeof bcs.CallArg.$inferType | string {
+  asCallArg(): CallArg | string {
     if (!this.version || !this.digest) {
       return this.objectId;
     }

package/src/libs/suiModel/suiSharedObject.ts

@@ -1,4 +1,4 @@
-import { bcs } from '@mysten/sui/bcs';
+import type { CallArg } from '@mysten/sui/transactions';
 
 export class SuiSharedObject {
   public readonly objectId: string;
@@ -13,7 +13,7 @@ export class SuiSharedObject {
     this.initialSharedVersion = param.initialSharedVersion;
   }
 
-  asCallArg(mutable: boolean = false): typeof bcs.CallArg.$inferType | string {
+  asCallArg(mutable: boolean = false): CallArg | string {
     if (!this.initialSharedVersion) {
       return this.objectId;
     }

package/src/libs/suiTxBuilder/index.ts

@@ -5,7 +5,6 @@ import type {
   TransactionObjectArgument,
   TransactionObjectInput,
 } from '@mysten/sui/transactions';
-import { bcs } from '@mysten/sui/bcs';
 import type { Keypair } from '@mysten/sui/cryptography';
 import { SerializedBcs } from '@mysten/bcs';
 
@@ -16,14 +15,16 @@ import type {
   SuiAddressArg,
   SuiObjectArg,
   SuiVecTxArg,
+  SuiAmountsArg,
 } from '../../types';
+
+import type { bcs } from '@mysten/sui/bcs';
 import {
   convertArgs,
   convertAddressArg,
   convertObjArg,
-  getDefaultSuiInputType,
+  convertAmounts,
 } from './util';
-
 export class SuiTx {
   public tx: Transaction;
 
@@ -43,7 +44,7 @@ export class SuiTx {
     return this.tx.blockData;
   }
 
-  autoPure(value: string, type?: string) {
+  autoPure(value: SuiTxArg, type?: string) {
     if (type === undefined) {
       return convertArgs(this.tx, [value]);
     }
@@ -54,10 +55,10 @@ export class SuiTx {
   address(value: string) {
     return this.tx.pure.address(value);
   }
-  pure(value: SerializedBcs<any, any> | Uint8Array) {
-    return this.tx.pure(value);
+  get pure() {
+    return this.tx.pure.bind(this.tx);
   }
-  object(value: TransactionObjectInput) {
+  object(value: string | TransactionObjectInput) {
     return this.tx.object(value);
   }
   objectRef(ref: SuiObjectRef) {
@@ -72,7 +73,7 @@ export class SuiTx {
   setSenderIfNotSet(sender: string) {
     return this.tx.setSenderIfNotSet(sender);
   }
-  setExpiration(expiration?: typeof bcs.TransactionExpiration.$inferType) {
+  setExpiration(expiration?: Parameters<typeof this.tx.setExpiration>[0]) {
     return this.tx.setExpiration(expiration);
   }
   setGasPrice(price: number | bigint) {
@@ -90,6 +91,9 @@ export class SuiTx {
   serialize() {
     return this.tx.serialize();
   }
+  toJSON() {
+    return this.tx.toJSON();
+  }
   sign(params: {
     signer: Keypair;
     client?: SuiClient;
@@ -108,7 +112,7 @@ export class SuiTx {
   getDigest(params: { client?: SuiClient } = {}) {
     return this.tx.getDigest(params);
   }
-  add(...args: TransactionType) {
+  add(...args: Parameters<typeof this.tx.add>) {
     return this.tx.add(...args);
   }
   publish({
@@ -120,32 +124,11 @@ export class SuiTx {
   }) {
     return this.tx.publish({ modules, dependencies });
   }
-  upgrade({
-    modules,
-    dependencies,
-    package: packageId,
-    ticket,
-  }: {
-    modules: number[][] | string[];
-    dependencies: string[];
-    package: string;
-    ticket: TransactionObjectArgument | string;
-  }) {
-    return this.tx.upgrade({
-      modules,
-      dependencies,
-      package: packageId,
-      ticket,
-    });
+  upgrade(...args: Parameters<typeof this.tx.upgrade>) {
+    return this.tx.upgrade(...args);
   }
-  makeMoveVec({
-    elements,
-    type,
-  }: {
-    elements: (TransactionObjectArgument | string)[];
-    type?: string;
-  }) {
-    return this.tx.makeMoveVec({ elements, type });
+  makeMoveVec(...args: Parameters<typeof this.tx.makeMoveVec>) {
+    return this.tx.makeMoveVec(...args);
   }
 
   /* Override methods of TransactionBlock */
@@ -202,7 +185,10 @@ export class SuiTx {
 
   /* 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(
@@ -211,7 +197,11 @@ export class SuiTx {
     }
     const coins = this.tx.splitCoins(
       this.tx.gas,
-      convertArgs(this.tx, amounts)
+      amounts.map((amount) =>
+        typeof amount === 'number' || typeof amount === 'bigint'
+          ? amount
+          : convertArgs(this.tx, [amount])[0]
+      )
     );
     const recipientObjects = recipients.map((recipient) =>
       convertAddressArg(this.tx, recipient)
@@ -222,20 +212,24 @@ export class SuiTx {
     return this;
   }
 
-  transferSui(address: SuiAddressArg, amount: SuiTxArg) {
+  transferSui(address: SuiAddressArg, amount: SuiTxArg | number | bigint) {
     return this.transferSuiToMany([address], [amount]);
   }
 
-  takeAmountFromCoins(coins: SuiObjectArg[], amount: SuiTxArg) {
+  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.tx.mergeCoins(mergedCoin, coinObjects.slice(1));
     }
-    const [sendCoin] = this.tx.splitCoins(
-      mergedCoin,
-      convertArgs(this.tx, [amount])
-    );
+    const [sendCoin] = this.tx.splitCoins(mergedCoin, [
+      typeof amount === 'number' || typeof amount === 'bigint'
+        ? amount
+        : convertArgs(this.tx, [amount])[0],
+    ]);
     return [sendCoin, mergedCoin];
   }
 
@@ -243,7 +237,7 @@ export class SuiTx {
     return this.tx.splitCoins(this.tx.gas, convertArgs(this.tx, amounts));
   }
 
-  splitMultiCoins(coins: SuiObjectArg[], amounts: SuiTxArg[]) {
+  splitMultiCoins(coins: SuiObjectArg[], amounts: SuiAmountsArg[]) {
     const coinObjects = coins.map((coin) => convertObjArg(this.tx, coin));
     const mergedCoin = coinObjects[0];
     if (coins.length > 1) {
@@ -251,7 +245,7 @@ export class SuiTx {
     }
     const splitedCoins = this.tx.splitCoins(
       mergedCoin,
-      convertArgs(this.tx, amounts)
+      convertAmounts(this.tx, amounts)
     );
     return { splitedCoins, mergedCoin };
   }
@@ -260,7 +254,7 @@ export class SuiTx {
     coins: SuiObjectArg[],
     sender: SuiAddressArg,
     recipients: SuiAddressArg[],
-    amounts: SuiTxArg[]
+    amounts: SuiAmountsArg[]
   ) {
     // require recipients.length === amounts.length
     if (recipients.length !== amounts.length) {
@@ -292,17 +286,17 @@ export class SuiTx {
     return this.transferCoinToMany(coins, sender, [recipient], [amount]);
   }
 
-  stakeSui(amount: SuiTxArg, validatorAddr: SuiAddressArg) {
+  stakeSui(amount: SuiTxArg | number | bigint, validatorAddr: SuiAddressArg) {
     const [stakeCoin] = this.tx.splitCoins(
       this.tx.gas,
-      convertArgs(this.tx, [amount])
+      convertAmounts(this.tx, [amount])
     );
     return this.tx.moveCall({
       target: '0x3::sui_system::request_add_stake',
       arguments: convertArgs(this.tx, [
-        SUI_SYSTEM_STATE_OBJECT_ID,
+        this.tx.object(SUI_SYSTEM_STATE_OBJECT_ID),
         stakeCoin,
-        this.tx.pure.address(validatorAddr.toString()),
+        convertAddressArg(this.tx, validatorAddr),
       ]),
     });
   }