@scallop-io/sui-kit 1.4.3 → 2.0.0

package/dist/index.d.ts

@@ -1,8 +1,747 @@
 export * from '@mysten/sui/utils';
+import * as _mysten_sui_transactions from '@mysten/sui/transactions';
+import { Transaction, TransactionObjectInput, Argument, TransactionArgument, TransactionObjectArgument, Inputs, CallArg } from '@mysten/sui/transactions';
 export * from '@mysten/sui/transactions';
-export { SuiKit } from './suiKit';
-export { SuiAccountManager } from './libs/suiAccountManager';
-export { SuiTxBlock } from './libs/suiTxBuilder';
-export { MultiSigClient } from './libs/multiSig';
-export { SuiInteractor } from './libs/suiInteractor';
-export type * from './types';
+import * as _mysten_sui_cryptography from '@mysten/sui/cryptography';
+import { Keypair, PublicKey } from '@mysten/sui/cryptography';
+import * as _mysten_bcs from '@mysten/bcs';
+import { SerializedBcs } from '@mysten/bcs';
+import * as _mysten_sui_client from '@mysten/sui/client';
+import { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { bcs } from '@mysten/sui/bcs';
+import * as _mysten_sui_keypairs_ed25519 from '@mysten/sui/keypairs/ed25519';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { MultiSigPublicKey } from '@mysten/sui/multisig';
+
+interface SuiObjectRef$1 {
+    objectId: string;
+    version: number | string;
+    digest: string;
+}
+declare class SuiTxBlock {
+    txBlock: Transaction;
+    constructor(transaction?: Transaction);
+    get gas(): {
+        $kind: "GasCoin";
+        GasCoin: true;
+    };
+    getData(): {
+        version: 2;
+        sender?: string | null | undefined;
+        expiration?: _mysten_bcs.EnumOutputShapeWithKeys<{
+            None: true;
+            Epoch: string | number;
+            ValidDuring: {
+                minEpoch: string | number | null;
+                maxEpoch: string | number | null;
+                minTimestamp: string | number | null;
+                maxTimestamp: string | number | null;
+                chain: string;
+                nonce: number;
+            };
+        }, "None" | "Epoch" | "ValidDuring"> | null | undefined;
+        gasData: {
+            budget: string | number | null;
+            price: string | number | null;
+            owner: string | null;
+            payment: {
+                objectId: string;
+                version: string | number;
+                digest: string;
+            }[] | null;
+        };
+        inputs: _mysten_bcs.EnumOutputShapeWithKeys<{
+            Object: _mysten_bcs.EnumOutputShapeWithKeys<{
+                ImmOrOwnedObject: {
+                    objectId: string;
+                    version: string | number;
+                    digest: string;
+                };
+                SharedObject: {
+                    objectId: string;
+                    initialSharedVersion: string | number;
+                    mutable: boolean;
+                };
+                Receiving: {
+                    objectId: string;
+                    version: string | number;
+                    digest: string;
+                };
+            }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
+            Pure: {
+                bytes: string;
+            };
+            UnresolvedPure: {
+                value: unknown;
+            };
+            UnresolvedObject: {
+                objectId: string;
+                version?: string | number | null | undefined;
+                digest?: string | null | undefined;
+                initialSharedVersion?: string | number | null | undefined;
+                mutable?: boolean | null | undefined;
+            };
+            FundsWithdrawal: {
+                reservation: {
+                    MaxAmountU64: string | number;
+                    $kind: "MaxAmountU64";
+                };
+                typeArg: {
+                    Balance: string;
+                    $kind: "Balance";
+                };
+                withdrawFrom: _mysten_bcs.EnumOutputShapeWithKeys<{
+                    Sender: true;
+                    Sponsor: true;
+                }, "Sender" | "Sponsor">;
+            };
+        }, "Pure" | "Object" | "FundsWithdrawal" | "UnresolvedPure" | "UnresolvedObject">[];
+        commands: _mysten_bcs.EnumOutputShapeWithKeys<{
+            MoveCall: {
+                package: string;
+                module: string;
+                function: string;
+                typeArguments: string[];
+                arguments: ({
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                })[];
+                _argumentTypes?: {
+                    reference: "mutable" | "unknown" | "immutable" | null;
+                    body: _mysten_sui_client.SuiClientTypes.OpenSignatureBody;
+                }[] | null | undefined;
+            };
+            TransferObjects: {
+                objects: ({
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                })[];
+                address: {
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                };
+            };
+            SplitCoins: {
+                coin: {
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                };
+                amounts: ({
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                })[];
+            };
+            MergeCoins: {
+                destination: {
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                };
+                sources: ({
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                })[];
+            };
+            Publish: {
+                modules: string[];
+                dependencies: string[];
+            };
+            MakeMoveVec: {
+                type: string | null;
+                elements: ({
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                })[];
+            };
+            Upgrade: {
+                modules: string[];
+                dependencies: string[];
+                package: string;
+                ticket: {
+                    GasCoin: true;
+                    $kind: "GasCoin";
+                } | {
+                    Input: number;
+                    type?: "object" | "pure" | "withdrawal" | undefined;
+                    $kind: "Input";
+                } | {
+                    Result: number;
+                    $kind: "Result";
+                } | {
+                    NestedResult: [number, number];
+                    $kind: "NestedResult";
+                };
+            };
+            $Intent: {
+                name: string;
+                inputs: {
+                    [x: string]: {
+                        GasCoin: true;
+                        $kind: "GasCoin";
+                    } | {
+                        Input: number;
+                        type?: "object" | "pure" | "withdrawal" | undefined;
+                        $kind: "Input";
+                    } | {
+                        Result: number;
+                        $kind: "Result";
+                    } | {
+                        NestedResult: [number, number];
+                        $kind: "NestedResult";
+                    } | ({
+                        GasCoin: true;
+                        $kind: "GasCoin";
+                    } | {
+                        Input: number;
+                        type?: "object" | "pure" | "withdrawal" | undefined;
+                        $kind: "Input";
+                    } | {
+                        Result: number;
+                        $kind: "Result";
+                    } | {
+                        NestedResult: [number, number];
+                        $kind: "NestedResult";
+                    })[];
+                };
+                data: {
+                    [x: string]: unknown;
+                };
+            };
+        }, "MoveCall" | "TransferObjects" | "SplitCoins" | "MergeCoins" | "Publish" | "MakeMoveVec" | "Upgrade" | "$Intent">[];
+    };
+    address(value: string): {
+        GasCoin: true;
+        $kind: "GasCoin";
+    } | {
+        Input: number;
+        type?: "object" | "pure" | "withdrawal" | undefined;
+        $kind: "Input";
+    } | {
+        Result: number;
+        $kind: "Result";
+    } | {
+        NestedResult: [number, number];
+        $kind: "NestedResult";
+    };
+    get pure(): typeof this$1.txBlock.pure;
+    object(value: string | TransactionObjectInput): {
+        $kind: "Input";
+        Input: number;
+        type?: "object";
+    };
+    objectRef(ref: SuiObjectRef$1): {
+        $kind: "Input";
+        Input: number;
+        type?: "object";
+    };
+    sharedObjectRef(ref: typeof bcs.SharedObjectRef.$inferType): {
+        $kind: "Input";
+        Input: number;
+        type?: "object";
+    };
+    setSender(sender: string): void;
+    setSenderIfNotSet(sender: string): void;
+    setExpiration(expiration?: Parameters<typeof this$1.txBlock.setExpiration>[0]): void;
+    setGasPrice(price: number | bigint): void;
+    setGasBudget(budget: number | bigint): void;
+    setGasOwner(owner: string): void;
+    setGasPayment(payments: SuiObjectRef$1[]): void;
+    /**
+     * @deprecated Use toJSON instead.
+     * For synchronous serialization, you can use `getData()`
+     * */
+    serialize(): string;
+    toJSON(): Promise<string>;
+    sign(params: {
+        signer: Keypair;
+        client?: ClientWithCoreApi;
+        onlyTransactionKind?: boolean;
+    }): Promise<_mysten_sui_cryptography.SignatureWithBytes>;
+    build(params?: {
+        client?: ClientWithCoreApi;
+        onlyTransactionKind?: boolean;
+    }): Promise<any>;
+    getDigest(params?: {
+        client?: ClientWithCoreApi;
+    }): Promise<string>;
+    add(...args: Parameters<typeof this$1.txBlock.add>): void | ({
+        Result: number;
+        $kind: "Result";
+    } | readonly {
+        NestedResult: [number, number];
+        $kind: "NestedResult";
+    }[]);
+    publish({ modules, dependencies, }: {
+        modules: number[][] | string[];
+        dependencies: string[];
+    }): _mysten_sui_transactions.TransactionResult;
+    upgrade(...args: Parameters<typeof this$1.txBlock.upgrade>): _mysten_sui_transactions.TransactionResult;
+    makeMoveVec(...args: Parameters<typeof this$1.txBlock.makeMoveVec>): _mysten_sui_transactions.TransactionResult;
+    transferObjects(objects: SuiObjectArg[], address: SuiAddressArg): _mysten_sui_transactions.TransactionResult;
+    splitCoins(coin: SuiObjectArg, amounts: SuiAmountsArg[]): {
+        NestedResult: [number, number];
+        $kind: "NestedResult";
+    }[];
+    mergeCoins(destination: SuiObjectArg, sources: SuiObjectArg[]): _mysten_sui_transactions.TransactionResult;
+    /**
+     * @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[]): _mysten_sui_transactions.TransactionResult;
+    transferSuiToMany(recipients: SuiAddressArg[], amounts: SuiAmountsArg[]): this;
+    transferSui(address: SuiAddressArg, amount: SuiAmountsArg): this;
+    takeAmountFromCoins(coins: SuiObjectArg[], amount: SuiAmountsArg): _mysten_sui_transactions.TransactionObjectArgument[];
+    splitSUIFromGas(amounts: SuiAmountsArg[]): {
+        Result: number;
+        $kind: "Result";
+    } & {
+        NestedResult: [number, number];
+        $kind: "NestedResult";
+    }[];
+    splitMultiCoins(coins: SuiObjectArg[], amounts: SuiAmountsArg[]): {
+        splitedCoins: {
+            Result: number;
+            $kind: "Result";
+        } & {
+            NestedResult: [number, number];
+            $kind: "NestedResult";
+        }[];
+        mergedCoin: _mysten_sui_transactions.TransactionObjectArgument;
+    };
+    transferCoinToMany(coins: SuiObjectArg[], sender: SuiAddressArg, recipients: SuiAddressArg[], amounts: SuiAmountsArg[]): this;
+    transferCoin(coins: SuiObjectArg[], sender: SuiAddressArg, recipient: SuiAddressArg, amount: SuiAmountsArg): this;
+    stakeSui(amount: SuiAmountsArg, validatorAddr: SuiAddressArg): _mysten_sui_transactions.TransactionResult;
+}
+
+type SuiKitParams = (AccountManagerParams & {
+    faucetUrl?: string;
+    networkType?: NetworkType;
+}) & Partial<SuiInteractorParams>;
+type SuiInteractorParams = {
+    fullnodeUrls: string[];
+    network?: NetworkType;
+} | {
+    suiClients: ClientWithCoreApi[];
+};
+type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
+type AccountManagerParams = {
+    mnemonics?: string;
+    secretKey?: string;
+};
+type DerivePathParams = {
+    accountIndex?: number;
+    isExternal?: boolean;
+    addressIndex?: number;
+};
+type TransactionBlockType = InstanceType<typeof Transaction>;
+type PureCallArg = {
+    Pure: number[];
+};
+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;
+};
+/**
+ * An object argument.
+ */
+type ObjectArg = {
+    ImmOrOwnedObject: SuiObjectRef;
+} | {
+    SharedObject: SharedObjectRef;
+} | {
+    Receiving: SuiObjectRef;
+};
+type ObjectCallArg = {
+    Object: ObjectArg;
+};
+type TransactionType = Parameters<TransactionBlockType['add']>;
+type TransactionPureArgument = Extract<Argument, {
+    $kind: 'Input';
+    type?: 'pure';
+}>;
+type SuiTxArg = TransactionArgument | SerializedBcs<any>;
+type SuiAddressArg = Argument | SerializedBcs<any> | string;
+type SuiAmountsArg = SuiTxArg | number | bigint;
+type SuiObjectArg = TransactionObjectArgument | string | Parameters<typeof Inputs.ObjectRef>[0] | Parameters<typeof Inputs.SharedObjectRef>[0] | ObjectCallArg;
+type SuiVecTxArg = {
+    value: SuiTxArg[];
+    vecType: SuiInputTypes;
+} | SuiTxArg[];
+/**
+ * These are the basics types that can be used in the SUI
+ */
+type SuiBasicTypes = 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256';
+type SuiInputTypes = 'object' | SuiBasicTypes;
+type SuiTransactionResult<Include extends SuiClientTypes.TransactionInclude = {}> = SuiClientTypes.TransactionResult<Include>;
+type SuiTransactionBlockResponse = SuiClientTypes.TransactionResult<{
+    balanceChanges: true;
+    effects: true;
+    events: true;
+    objectTypes: true;
+}>;
+type SuiKitReturnType<T extends boolean> = T extends true ? SuiTransactionBlockResponse : SuiTxBlock;
+
+type TransactionResultWithEffects = SuiClientTypes.TransactionResult<{
+    effects: true;
+}>;
+declare class SuiOwnedObject {
+    readonly objectId: string;
+    version?: string;
+    digest?: string;
+    constructor(param: {
+        objectId: string;
+        version?: string;
+        digest?: string;
+    });
+    /**
+     * 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;
+    asCallArg(): CallArg | string;
+    /**
+     * Update object version & digest based on the transaction response.
+     * @param txResponse
+     */
+    updateFromTxResponse(txResponse: TransactionResultWithEffects): void;
+}
+
+declare class SuiSharedObject {
+    readonly objectId: string;
+    initialSharedVersion?: string;
+    constructor(param: {
+        objectId: string;
+        initialSharedVersion?: string;
+        mutable?: boolean;
+    });
+    asCallArg(mutable?: boolean): CallArg | string;
+}
+
+declare function getFullnodeUrl(network: NetworkType): string;
+type SuiObjectData = SuiClientTypes.Object<{
+    content: true;
+    json: true;
+}>;
+type SuiObjectDataOptions = SuiClientTypes.ObjectInclude;
+type SimulateTransactionResponse = SuiClientTypes.SimulateTransactionResult<{
+    effects: true;
+    events: true;
+    balanceChanges: true;
+    commandResults: true;
+}>;
+/**
+ * Encapsulates all functions that interact with the sui sdk
+ */
+declare class SuiInteractor {
+    private clients;
+    currentClient: ClientWithCoreApi;
+    private fullNodes;
+    private network;
+    constructor(params: Partial<SuiInteractorParams>);
+    switchToNextClient(): void;
+    switchFullNodes(fullNodes: string[], network?: NetworkType): void;
+    get currentFullNode(): string;
+    sendTx(transactionBlock: Uint8Array | string, signature: string | string[]): Promise<SuiClientTypes.TransactionResult<{
+        balanceChanges: true;
+        effects: true;
+        events: true;
+        objectTypes: true;
+    }>>;
+    dryRunTx(transactionBlock: Uint8Array): Promise<SimulateTransactionResponse>;
+    getObjects(ids: string[], options?: {
+        include?: SuiObjectDataOptions;
+        batchSize?: number;
+        switchClientDelay?: number;
+    }): Promise<SuiObjectData[]>;
+    getObject(id: string, options?: {
+        include?: SuiObjectDataOptions;
+    }): Promise<SuiObjectData>;
+    /**
+     * @description Update objects in a batch
+     * @param suiObjects
+     */
+    updateObjects(suiObjects: (SuiOwnedObject | SuiSharedObject)[]): Promise<void>;
+    /**
+     * @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'
+     */
+    selectCoins(addr: string, amount: number, coinType?: string): Promise<{
+        objectId: string;
+        digest: string;
+        version: string;
+        balance: string;
+    }[]>;
+}
+
+declare class SuiAccountManager {
+    private mnemonics;
+    private secretKey;
+    currentKeyPair: Ed25519Keypair;
+    currentAddress: string;
+    /**
+     * Support the following ways to init the SuiToolkit:
+     * 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 string, when mnemonics is provided, secretKey will be ignored
+     */
+    constructor({ mnemonics, secretKey }?: AccountManagerParams);
+    /**
+     * Check if the secretKey starts with bench32 format
+     */
+    parseSecretKey(secretKey: string): Ed25519Keypair;
+    /**
+     * if derivePathParams is not provided or mnemonics is empty, it will return the currentKeyPair.
+     * else:
+     * it will generate keyPair from the mnemonic with the given derivePathParams.
+     */
+    getKeyPair(derivePathParams?: DerivePathParams): Ed25519Keypair;
+    /**
+     * if derivePathParams is not provided or mnemonics is empty, it will return the currentAddress.
+     * else:
+     * it will generate address from the mnemonic with the given derivePathParams.
+     */
+    getAddress(derivePathParams?: DerivePathParams): string;
+    /**
+     * Switch the current account with the given derivePathParams.
+     * This is only useful when the mnemonics is provided. For secretKey mode, it will always use the same account.
+     */
+    switchAccount(derivePathParams: DerivePathParams): void;
+}
+
+/**
+ * @class SuiKit
+ * @description This class is used to aggregate the tools that used to interact with SUI network.
+ */
+declare class SuiKit {
+    accountManager: SuiAccountManager;
+    suiInteractor: SuiInteractor;
+    /**
+     * Support the following ways to init the SuiToolkit:
+     * 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 'mainnet'
+     * @param fullnodeUrls, the fullnode url, default is the preconfig fullnode url for the given network type
+     */
+    constructor(params: SuiKitParams);
+    /**
+     * Create SuiTxBlock with sender set to the current signer
+     * @returns SuiTxBlock with sender set to the current signer
+     */
+    createTxBlock(): SuiTxBlock;
+    /**
+     * 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): _mysten_sui_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;
+    get currentAddress(): string;
+    getBalance(coinType?: string, derivePathParams?: DerivePathParams): Promise<_mysten_sui_client.SuiClientTypes.Balance>;
+    get client(): _mysten_sui_client.ClientWithCoreApi;
+    getObjects(objectIds: string[], options?: {
+        include?: SuiObjectDataOptions;
+        batchSize?: number;
+        switchClientDelay?: number;
+    }): Promise<SuiObjectData[]>;
+    /**
+     * @description Update objects in a batch
+     * @param suiObjects
+     */
+    updateObjects(suiObjects: (SuiSharedObject | SuiOwnedObject)[]): Promise<void>;
+    signTxn(tx: Uint8Array | Transaction | SuiTxBlock, derivePathParams?: DerivePathParams): Promise<_mysten_sui_cryptography.SignatureWithBytes>;
+    signAndSendTxn(tx: Uint8Array | Transaction | SuiTxBlock, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    dryRunTxn(tx: Uint8Array | Transaction | SuiTxBlock, derivePathParams?: DerivePathParams): Promise<SimulateTransactionResponse>;
+    /**
+     * Transfer the given amount of SUI to the recipient
+     * @param recipient
+     * @param amount
+     * @param derivePathParams
+     */
+    transferSui(recipient: string, amount: number, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    transferSui<S extends boolean>(recipient: string, amount: number, sign?: S, derivePathParams?: DerivePathParams): Promise<SuiKitReturnType<S>>;
+    /**
+     * 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>;
+    transferSuiToMany<S extends boolean>(recipients: string[], amounts: number[], sign?: S, derivePathParams?: DerivePathParams): Promise<SuiKitReturnType<S>>;
+    /**
+     * 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>;
+    transferCoinToMany<S extends boolean>(recipients: string[], amounts: number[], coinType: string, sign?: S, derivePathParams?: DerivePathParams): Promise<SuiKitReturnType<S>>;
+    transferCoin(recipient: string, amount: number, coinType: string, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    transferCoin<S extends boolean>(recipient: string, amount: number, coinType: string, sign?: S, derivePathParams?: DerivePathParams): Promise<SuiKitReturnType<S>>;
+    transferObjects(objects: SuiObjectArg[], recipient: string, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    transferObjects<S extends boolean>(objects: SuiObjectArg[], recipient: string, sign?: S, derivePathParams?: DerivePathParams): Promise<SuiKitReturnType<S>>;
+    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<{
+        objectId: string;
+        digest: string;
+        version: string;
+        balance: string;
+    }[]>;
+    /**
+     * stake the given amount of SUI to the validator
+     * @param amount the amount of SUI to stake
+     * @param validatorAddr the validator address
+     * @param sign whether to sign and send the transaction, default is true
+     * @param derivePathParams the derive path params for the current signer
+     */
+    stakeSui(amount: number, validatorAddr: string, derivePathParams?: DerivePathParams): Promise<SuiTransactionBlockResponse>;
+    stakeSui<S extends boolean>(amount: number, validatorAddr: string, sign?: S, derivePathParams?: DerivePathParams): Promise<SuiKitReturnType<S>>;
+    /**
+     * 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 | SuiTxBlock, derivePathParams?: DerivePathParams): Promise<SimulateTransactionResponse>;
+}
+
+type PublicKeyWeightPair = {
+    publicKey: PublicKey;
+    weight: number;
+};
+declare class MultiSigClient {
+    readonly pksWeightPairs: PublicKeyWeightPair[];
+    readonly threshold: number;
+    readonly multiSigPublicKey: MultiSigPublicKey;
+    constructor(pks: PublicKeyWeightPair[], threshold: number);
+    static fromRawEd25519PublicKeys(rawPublicKeys: string[], weights: number[], threshold: number): MultiSigClient;
+    multiSigAddress(): string;
+    combinePartialSigs(sigs: string[]): string;
+}
+
+export { type AccountManagerParams, type DerivePathParams, MultiSigClient, type NetworkType, type ObjectCallArg, type PureCallArg, type SimulateTransactionResponse, SuiAccountManager, type SuiAddressArg, type SuiAmountsArg, type SuiBasicTypes, type SuiInputTypes, SuiInteractor, type SuiInteractorParams, SuiKit, type SuiKitParams, type SuiKitReturnType, type SuiObjectArg, type SuiTransactionBlockResponse, type SuiTransactionResult, type SuiTxArg, SuiTxBlock, type SuiVecTxArg, type TransactionPureArgument, type TransactionType, getFullnodeUrl };