@swapkit/toolboxes 4.23.0 → 4.24.1

package/dist/types/evm/toolbox/op.d.ts

@@ -1,32 +1,191 @@
-import { FeeOption } from "@swapkit/helpers";
+import { Chain, FeeOption } from "@swapkit/helpers";
 import type { Authorization, TransactionRequest } from "ethers";
 import { Contract } from "ethers";
 import type { EVMToolboxParams } from "../types";
-export declare function OPToolbox({ provider, ...toolboxSignerParams }: EVMToolboxParams): {
+export declare function createOPStackToolbox(chain: Chain.Optimism | Chain.Base | Chain.Unichain): ({ provider, ...toolboxSignerParams }: EVMToolboxParams) => {
+    estimateL1Gas: (tx: TransactionRequest) => Promise<any>;
+    estimateL1GasCost: (tx: TransactionRequest) => Promise<bigint | undefined>;
+    estimateL2GasCost: (tx: TransactionRequest) => Promise<bigint>;
+    estimateOperatorFee: (gasLimit: bigint) => Promise<bigint>;
+    estimateTotalGasCost: (tx: TransactionRequest) => Promise<bigint>;
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
+    getL1GasPrice: () => Promise<bigint | undefined>;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").ApproveParams) => Promise<{
+        value: string;
+        to: string;
+        data: string;
+        from?: string;
+        type?: number;
+        nonce?: number;
+        gasLimit?: bigint;
+        gasPrice?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        maxFeePerGas?: bigint;
+        chainId?: bigint;
+        accessList?: import("ethers").AccessList;
+        authorizationList?: Array<Authorization>;
+        customData?: any;
+        blockTag?: import("ethers").BlockTag;
+        enableCcipRead?: boolean;
+    }>;
+    createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => Contract;
+    createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").CallParams) => Promise<{
+        value: string;
+        to: string;
+        data: string;
+        from?: string;
+        type?: number;
+        nonce?: number;
+        gasLimit?: bigint;
+        gasPrice?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        maxFeePerGas?: bigint;
+        chainId?: bigint;
+        accessList?: import("ethers").AccessList;
+        authorizationList?: Array<Authorization>;
+        customData?: any;
+        blockTag?: import("ethers").BlockTag;
+        enableCcipRead?: boolean;
+    }>;
+    createTransaction: ({ assetValue, authorizations, memo, recipient, data, feeOptionKey, gasLimit, sender: fromOverride, sweep, type, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<{
+        gasLimit: bigint;
+        value: string;
+        data: string;
+        from: string;
+        to: string;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        gasPrice?: undefined;
+        type?: number | undefined;
+        nonce?: number | undefined;
+    } | {
+        gasLimit: bigint;
+        value: string;
+        data: string;
+        from: string;
+        to: string;
+        gasPrice: bigint;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        type?: number | undefined;
+        nonce?: number | undefined;
+    } | {
+        value: string;
+        to: string;
+        data: string;
+        from?: string;
+        type?: number;
+        nonce?: number;
+        gasLimit?: bigint;
+        gasPrice?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        maxFeePerGas?: bigint;
+        chainId?: bigint;
+        accessList?: import("ethers").AccessList;
+        authorizationList?: Array<Authorization>;
+        customData?: any;
+        blockTag?: import("ethers").BlockTag;
+        enableCcipRead?: boolean;
+    }>;
+    createTransferTx: ({ assetValue, authorizations, memo, recipient, data, feeOptionKey, gasLimit, sender: fromOverride, sweep, type, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<{
+        gasLimit: bigint;
+        value: string;
+        data: string;
+        from: string;
+        to: string;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        gasPrice?: undefined;
+        type?: number | undefined;
+        nonce?: number | undefined;
+    } | {
+        gasLimit: bigint;
+        value: string;
+        data: string;
+        from: string;
+        to: string;
+        gasPrice: bigint;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        type?: number | undefined;
+        nonce?: number | undefined;
+    } | {
+        value: string;
+        to: string;
+        data: string;
+        from?: string;
+        type?: number;
+        nonce?: number;
+        gasLimit?: bigint;
+        gasPrice?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        maxFeePerGas?: bigint;
+        chainId?: bigint;
+        accessList?: import("ethers").AccessList;
+        authorizationList?: Array<Authorization>;
+        customData?: any;
+        blockTag?: import("ethers").BlockTag;
+        enableCcipRead?: boolean;
+    }>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@swapkit/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
     estimateGasPrices: () => Promise<{
         average: {
-            l1GasPrice?: bigint;
             gasPrice?: bigint;
+            l1GasPrice?: bigint;
             maxFeePerGas?: bigint;
             maxPriorityFeePerGas?: bigint;
         };
         fast: {
-            l1GasPrice?: bigint;
             gasPrice?: bigint;
+            l1GasPrice?: bigint;
             maxFeePerGas?: bigint;
             maxPriorityFeePerGas?: bigint;
         };
         fastest: {
-            l1GasPrice?: bigint;
             gasPrice?: bigint;
+            l1GasPrice?: bigint;
             maxFeePerGas?: bigint;
             maxPriorityFeePerGas?: bigint;
         };
     }>;
+    estimateTransactionFee: ({ feeOption, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+    }) => Promise<import("@swapkit/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    getNetworkParams: () => import("@swapkit/helpers").NetworkParams | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, sweep, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+        sweep?: boolean;
+    }) => Promise<string>;
+    signAuthorization: ((params: {
+        address: string;
+        nonce?: number | bigint;
+        chainId?: bigint;
+    }) => Promise<Authorization>) | undefined;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
+};
+export declare const OPToolbox: ({ provider, ...toolboxSignerParams }: EVMToolboxParams) => {
     estimateL1Gas: (tx: TransactionRequest) => Promise<any>;
-    estimateL1GasCost: (tx: TransactionRequest) => Promise<any>;
+    estimateL1GasCost: (tx: TransactionRequest) => Promise<bigint | undefined>;
     estimateL2GasCost: (tx: TransactionRequest) => Promise<bigint>;
-    estimateTotalGasCost: (tx: TransactionRequest) => Promise<any>;
+    estimateOperatorFee: (gasLimit: bigint) => Promise<bigint>;
+    estimateTotalGasCost: (tx: TransactionRequest) => Promise<bigint>;
     getBalance: (address: string, scamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
     getL1GasPrice: () => Promise<bigint | undefined>;
     approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
@@ -70,7 +229,29 @@ export declare function OPToolbox({ provider, ...toolboxSignerParams }: EVMToolb
         blockTag?: import("ethers").BlockTag;
         enableCcipRead?: boolean;
     }>;
-    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<{
+    createTransaction: ({ assetValue, authorizations, memo, recipient, data, feeOptionKey, gasLimit, sender: fromOverride, sweep, type, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<{
+        gasLimit: bigint;
+        value: string;
+        data: string;
+        from: string;
+        to: string;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        gasPrice?: undefined;
+        type?: number | undefined;
+        nonce?: number | undefined;
+    } | {
+        gasLimit: bigint;
+        value: string;
+        data: string;
+        from: string;
+        to: string;
+        gasPrice: bigint;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        type?: number | undefined;
+        nonce?: number | undefined;
+    } | {
         value: string;
         to: string;
         data: string;
@@ -88,7 +269,29 @@ export declare function OPToolbox({ provider, ...toolboxSignerParams }: EVMToolb
         blockTag?: import("ethers").BlockTag;
         enableCcipRead?: boolean;
     }>;
-    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<{
+    createTransferTx: ({ assetValue, authorizations, memo, recipient, data, feeOptionKey, gasLimit, sender: fromOverride, sweep, type, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<{
+        gasLimit: bigint;
+        value: string;
+        data: string;
+        from: string;
+        to: string;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        gasPrice?: undefined;
+        type?: number | undefined;
+        nonce?: number | undefined;
+    } | {
+        gasLimit: bigint;
+        value: string;
+        data: string;
+        from: string;
+        to: string;
+        gasPrice: bigint;
+        maxFeePerGas?: undefined;
+        maxPriorityFeePerGas?: undefined;
+        type?: number | undefined;
+        nonce?: number | undefined;
+    } | {
         value: string;
         to: string;
         data: string;
@@ -115,14 +318,35 @@ export declare function OPToolbox({ provider, ...toolboxSignerParams }: EVMToolb
         txOverrides?: import("..").EVMTxParams;
         data?: string;
     }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{
+        average: {
+            gasPrice?: bigint;
+            l1GasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+        };
+        fast: {
+            gasPrice?: bigint;
+            l1GasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+        };
+        fastest: {
+            gasPrice?: bigint;
+            l1GasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+        };
+    }>;
     estimateTransactionFee: ({ feeOption, ...txObject }: import("..").EIP1559TxParams & {
         feeOption: FeeOption;
     }) => Promise<import("@swapkit/helpers").AssetValue>;
     getAddress: () => string | Promise<string> | undefined;
     getNetworkParams: () => import("@swapkit/helpers").NetworkParams | undefined;
     isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
-    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+    sendTransaction: ({ feeOptionKey, sweep, ...tx }: import("..").EVMTxParams & {
         feeOptionKey?: FeeOption;
+        sweep?: boolean;
     }) => Promise<string>;
     signAuthorization: ((params: {
         address: string;
@@ -131,6 +355,6 @@ export declare function OPToolbox({ provider, ...toolboxSignerParams }: EVMToolb
     }) => Promise<Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
     signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
-    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };

package/dist/types/evm/types.d.ts

@@ -1,6 +1,6 @@
-import type { AssetValue, ChainSigner, DerivationPathArray, FeeOption, GenericCreateTransactionParams, GenericTransferParams } from "@swapkit/helpers";
+import type { ChainSigner, DerivationPathArray, FeeOption, GenericCreateTransactionParams, GenericTransferParams } from "@swapkit/helpers";
 import { Chain } from "@swapkit/helpers";
-import type { BigNumberish, BrowserProvider, JsonFragment, JsonRpcSigner, Provider, Signer, TransactionRequest, TypedDataField } from "ethers";
+import type { AuthorizationLike, BigNumberish, BrowserProvider, JsonFragment, JsonRpcSigner, Provider, Signer, TransactionRequest, TypedDataField } from "ethers";
 import type { getProvider } from "./index";
 import type { ADIToolbox, ARBToolbox, AURORAToolbox, AVAXToolbox, BASEToolbox, BERAToolbox, BSCToolbox, COREToolbox, CORNToolbox, CROToolbox, ETHToolbox, GNOToolbox, HOODToolbox, HYPEREVMToolbox, LINEAToolbox, MATICToolbox, MEGAETHToolbox, MONADToolbox, OPToolbox, PLASMAToolbox, SONICToolbox, UNIToolbox, XLayerToolbox } from "./toolbox";
 export declare enum EthNetwork {
@@ -35,26 +35,20 @@ export type CallParams = {
 };
 export type EstimateCallParams = Pick<CallParams, "contractAddress" | "abi" | "funcName" | "funcParams" | "txOverrides">;
 export type EVMTransferParams = GenericTransferParams & {
+    authorizations?: AuthorizationLike[];
     sender?: string;
+    type?: number;
 };
 export type EVMCreateTransactionParams = Omit<GenericCreateTransactionParams, "feeRate"> & {
+    authorizations?: AuthorizationLike[];
+    feeOptionKey?: FeeOption;
     gasLimit?: bigint;
     gasPrice?: bigint;
     maxFeePerGas?: bigint;
     maxPriorityFeePerGas?: bigint;
     data?: string;
     nonce?: number;
-};
-export type EVMMaxSendableAmountsParams = {
-    from: string;
-    assetValue: AssetValue;
-    feeOptionKey?: FeeOption;
-    memo?: string;
-    abi?: readonly JsonFragment[];
-    funcName?: string;
-    contractAddress?: string;
-    funcParams?: unknown[];
-    txOverrides?: TransactionRequest;
+    type?: number;
 };
 export type EVMTxBaseParams<T = BigNumberish> = {
     to?: string;

package/dist/types/hypercore/toolbox.d.ts

@@ -44,7 +44,7 @@ declare function getUserFills({ aggregateByTime, user }: HyperCoreUserFillsQuery
 declare function getUserFillsByTime({ aggregateByTime, endTime, startTime, user }: HyperCoreUserFillsByTimeQueryParams): Promise<HyperCoreFill[]>;
 export declare function createL1ActionRequest<TAction extends HyperCoreL1Action>({ action, expiresAfter, nonce, vaultAddress, }: HyperCoreL1RequestParams<TAction>): Promise<HyperCoreUnsignedL1ActionRequest<TAction>>;
 export declare function createUserSignedActionRequest<TAction extends HyperCoreUserSignedAction>({ action, nonce, signatureChainId, }: HyperCoreUserSignedRequestParams<TAction>): Promise<HyperCoreUnsignedUserSignedActionRequest<TAction>>;
-export declare function createTransaction({ assetValue, recipient, sender, signatureChainId: customSignatureChainId, time, }: HyperCoreCreateTransactionParams): Promise<HyperCoreTransferTransaction>;
+export declare function createTransaction({ assetValue, recipient, sender, signatureChainId: customSignatureChainId, sweep, time, }: HyperCoreCreateTransactionParams): Promise<HyperCoreTransferTransaction>;
 declare function broadcastTransaction(signed: HyperCoreSignedRequest): Promise<{
     response?: {
         data?: {
@@ -72,7 +72,7 @@ export declare function getHyperCoreToolbox(toolboxParams?: HyperCoreToolboxPara
         userFillsByTime: typeof getUserFillsByTime;
     };
     signTransaction: (request: HyperCoreUnsignedRequest) => Promise<HyperCoreSignedRequest>;
-    transfer: (params: HyperCoreTransferParams) => Promise<string>;
+    transfer: ({ sweep, ...params }: HyperCoreTransferParams) => Promise<string>;
     validateAddress: typeof validateHyperCoreAddress;
 };
 export {};

package/dist/types/hypercore/types.d.ts

@@ -1,7 +1,9 @@
 import type { GenericCreateTransactionParams } from "@swapkit/helpers";
 import type { TypedDataDomain, TypedDataField } from "ethers";
-export type HyperCoreCreateTransactionParams = GenericCreateTransactionParams & {
+export type HyperCoreCreateTransactionParams = Omit<GenericCreateTransactionParams, "sweep"> & {
     signatureChainId?: string;
+    /** Drains the full spot token balance to another HyperCore account. Withdrawing off the exchange is out of scope. */
+    sweep?: boolean;
     time?: number;
 };
 export type HyperCoreTransferParams = Omit<HyperCoreCreateTransactionParams, "feeRate" | "sender"> & {

package/dist/types/near/toolbox.d.ts

@@ -1,10 +1,28 @@
 import type { Account, Contract } from "@near-js/accounts";
+import type { JsonRpcProvider } from "@near-js/providers";
 import type { SignedTransaction, Transaction } from "@near-js/transactions";
 import { AssetValue } from "@swapkit/helpers";
 import { getNearSignerFromPhrase, getNearSignerFromPrivateKey, validateNearAddress } from "./helpers/core";
 import type { NearCreateTransactionParams, NearFunctionCallParams, NearToolboxParams, NearTransferParams } from "./types";
 import type { NearContractInterface, NearGasEstimateParams } from "./types/contract";
 import type { BatchTransaction, ContractFunctionCallParams, CreateActionParams } from "./types/toolbox";
+type NearProtocolConfig = {
+    runtime_config: {
+        storage_amount_per_byte: string;
+        transaction_costs: {
+            action_creation_config: {
+                transfer_cost: {
+                    execution: string;
+                    send_sir: string;
+                };
+            };
+            action_receipt_creation_config: {
+                execution: string;
+                send_sir: string;
+            };
+        };
+    };
+};
 export declare function getNearToolbox(toolboxParams?: NearToolboxParams): {
     broadcastTransaction: (signedTransaction: SignedTransaction) => Promise<string>;
     callFunction: (params: NearFunctionCallParams) => Promise<string>;
@@ -12,16 +30,16 @@ export declare function getNearToolbox(toolboxParams?: NearToolboxParams): {
     createContract: <T extends Contract = Contract>(contractInterface: NearContractInterface) => Promise<T>;
     createContractFunctionCall: ({ args, attachedDeposit, contractId, gas, methodName, sender: accountId, }: ContractFunctionCallParams) => Promise<Transaction>;
     createSubAccount: (subAccountId: string, publicKey: string, initialBalance: string) => Promise<string>;
-    createTransaction: ({ recipient, assetValue, memo, attachedDeposit, sender, functionCall, }: NearCreateTransactionParams) => Promise<Transaction>;
+    createTransaction: ({ recipient, assetValue, memo, attachedDeposit, sender, functionCall, sweep, }: NearCreateTransactionParams) => Promise<Transaction>;
     /** @deprecated Use `estimateGasLimit` instead */
     estimateGas: (params: NearGasEstimateParams, account?: Account) => Promise<AssetValue>;
     estimateGasLimit: (params: NearGasEstimateParams, account?: Account) => Promise<AssetValue>;
-    estimateTransactionFee: (params: NearTransferParams | NearGasEstimateParams) => Promise<AssetValue>;
+    estimateTransactionFee: (params: NearTransferParams | NearGasEstimateParams, protocolConfigParam?: NearProtocolConfig) => Promise<AssetValue>;
     executeBatchTransaction: (batch: BatchTransaction) => Promise<string>;
     getAddress: () => Promise<string>;
     getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
     getGasPrice: () => Promise<string>;
-    getNearProvider: () => Promise<import("@near-js/providers").JsonRpcProvider>;
+    getNearProvider: () => Promise<JsonRpcProvider>;
     getPublicKey: () => Promise<string>;
     getSignerFromPhrase: typeof getNearSignerFromPhrase;
     getSignerFromPrivateKey: typeof getNearSignerFromPrivateKey;
@@ -31,3 +49,4 @@ export declare function getNearToolbox(toolboxParams?: NearToolboxParams): {
     transfer: (params: NearTransferParams) => Promise<string>;
     validateAddress: typeof validateNearAddress;
 };
+export {};

package/dist/types/near/types.d.ts

@@ -35,6 +35,7 @@ export type NearToolboxParams = {
     derivationPath?: DerivationPathArray;
 };
 export interface NearTransferParams extends GenericTransferParams {
+    sweep?: boolean;
 }
 export interface NearConfig {
     networkId: "mainnet" | "testnet" | "betanet";
@@ -50,7 +51,7 @@ export interface NearFunctionCallParams {
     deposit?: bigint | string | number;
     gas?: bigint | string | number;
 }
-export interface NearCreateTransactionParams extends Omit<GenericCreateTransactionParams, "feeRate"> {
+export interface NearCreateTransactionParams extends Omit<GenericCreateTransactionParams, "feeRate" | "sweep"> {
     attachedDeposit?: string;
     functionCall?: {
         methodName: string;
@@ -59,6 +60,8 @@ export interface NearCreateTransactionParams extends Omit<GenericCreateTransacti
         gas: string;
         contractId: string;
     };
+    /** Sweep the maximum transferable amount while keeping the account alive. DeleteAccount sweeps are out of scope. */
+    sweep?: boolean;
 }
 export * from "./toolbox";
 export * from "./types/contract";

package/dist/types/ripple/index.d.ts

@@ -54,11 +54,12 @@ type RippleToolboxParams = {
 export declare function getRippleToolbox(params?: RippleToolboxParams): {
     broadcastTransaction: (signedTxHex: string) => Promise<string>;
     createSigner: typeof createSigner;
-    createTransaction: ({ assetValue, recipient, memo, sender, destinationTag, extendBySeconds, }: {
+    createTransaction: ({ assetValue, recipient, memo, sender, sweep, destinationTag, extendBySeconds, }: {
         assetValue: AssetValue;
         recipient: string;
         sender?: string;
         memo?: string;
+        sweep?: boolean;
         destinationTag?: number;
         extendBySeconds?: number;
     }) => Promise<Payment>;
@@ -79,6 +80,6 @@ export declare function getRippleToolbox(params?: RippleToolboxParams): {
         tx_blob: string;
         hash: string;
     }>;
-    transfer: (params: GenericTransferParams) => Promise<string>;
+    transfer: ({ assetValue, memo, recipient, sweep }: GenericTransferParams) => Promise<string>;
     validateAddress: typeof validateRippleAddress;
 };

package/dist/types/solana/toolbox.d.ts

@@ -23,7 +23,7 @@ export declare function getSolanaToolbox(toolboxParams?: {
 }): {
     broadcastTransaction: (transaction: Transaction | VersionedTransaction) => Promise<string>;
     createKeysForPath: typeof createKeysForPath;
-    createTransaction: ({ recipient, assetValue, memo, isProgramDerivedAddress, sender }: SolanaCreateTransactionParams) => Promise<Transaction>;
+    createTransaction: ({ recipient, assetValue, memo, isProgramDerivedAddress, sender, sweep, }: SolanaCreateTransactionParams) => Promise<Transaction>;
     createTransactionFromInstructions: typeof createTransactionFromInstructions;
     estimateTransactionFee: ({ recipient, assetValue, memo, isProgramDerivedAddress, sender, }: Omit<GenericCreateTransactionParams, "feeRate"> & {
         isProgramDerivedAddress?: boolean;
@@ -36,7 +36,7 @@ export declare function getSolanaToolbox(toolboxParams?: {
     getPubkeyFromAddress: (address: string) => PublicKey;
     signAndBroadcastTransaction: (transaction: Transaction | VersionedTransaction) => Promise<string>;
     signTransaction: (transaction: Transaction | VersionedTransaction) => Promise<Transaction | VersionedTransaction>;
-    transfer: ({ recipient, assetValue, memo, isProgramDerivedAddress }: SolanaTransferParams) => Promise<string>;
+    transfer: ({ recipient, assetValue, memo, isProgramDerivedAddress, sweep }: SolanaTransferParams) => Promise<string>;
     validateAddress: typeof validateSolanaAddress;
 };
 declare function getConnection(): Promise<Connection>;

package/dist/types/starknet/toolbox.d.ts

@@ -17,7 +17,7 @@ export declare function createKeysForPath({ phrase, derivationPath, }: {
 export declare function getStarknetToolbox(toolboxParams?: StarknetToolboxParams): {
     broadcastTransaction: (calls: StarknetCall[]) => Promise<string>;
     createKeysForPath: typeof createKeysForPath;
-    createTransaction: ({ recipient, assetValue }: StarknetCreateTransactionParams) => Promise<StarknetCall[]>;
+    createTransaction: ({ recipient, assetValue, sender, sweep }: StarknetCreateTransactionParams) => Promise<StarknetCall[]>;
     deployAccount: () => Promise<string>;
     estimateTransactionFee: ({ recipient, assetValue, sender, }: StarknetTransferParams & {
         sender?: string;
@@ -28,6 +28,6 @@ export declare function getStarknetToolbox(toolboxParams?: StarknetToolboxParams
     isAccountDeployed: (address?: string) => Promise<boolean>;
     signAndBroadcastTransaction: (calls: StarknetCall[]) => Promise<string>;
     signMessage: (typedData: TypedData) => Promise<string[]>;
-    transfer: ({ recipient, assetValue, memo }: StarknetTransferParams) => Promise<string>;
+    transfer: ({ recipient, assetValue, memo, sweep }: StarknetTransferParams) => Promise<string>;
     validateAddress: typeof validateStarknetAddress;
 };

package/dist/types/starknet/types.d.ts

@@ -1,4 +1,4 @@
-import type { AssetValue, DerivationPathArray, FeeOption } from "@swapkit/helpers";
+import type { DerivationPathArray, GenericTransferParams } from "@swapkit/helpers";
 import type { Account } from "starknet";
 export type StarknetToolboxParams = {
     signer?: Account;
@@ -10,16 +10,7 @@ export type StarknetToolboxParams = {
     privateKey?: string;
     address?: string;
 };
-export type StarknetTransferParams = {
-    recipient: string;
-    assetValue: AssetValue;
-    memo?: string;
-};
-export type StarknetCreateTransactionParams = {
-    recipient: string;
-    assetValue: AssetValue;
+export type StarknetTransferParams = GenericTransferParams;
+export type StarknetCreateTransactionParams = GenericTransferParams & {
     sender?: string;
-    memo?: string;
-    feeRate?: number;
-    feeOptionKey?: FeeOption;
 };

package/dist/types/stellar/toolbox.d.ts

@@ -7,7 +7,7 @@ export declare function getStellarToolbox(params?: StellarToolboxParams): {
         hash?: () => Buffer;
         toXDR: () => string;
     }) => Promise<string>;
-    createTransaction: ({ recipient, assetValue, memo, sender }: StellarCreateTransactionParams) => Promise<import("@stellar/stellar-sdk").Transaction<import("@stellar/stellar-sdk").Memo<import("@stellar/stellar-sdk").MemoType>, import("@stellar/stellar-sdk").Operation[]>>;
+    createTransaction: ({ recipient, assetValue, memo, sender, sweep }: StellarCreateTransactionParams) => Promise<import("@stellar/stellar-sdk").Transaction<import("@stellar/stellar-sdk").Memo<import("@stellar/stellar-sdk").MemoType>, import("@stellar/stellar-sdk").Operation[]>>;
     createTrustline: ({ assetValue, limit }: StellarTrustlineParams) => Promise<string>;
     createTrustlineTransaction: ({ assetValue, limit, sender }: StellarCreateTrustlineTransactionParams) => Promise<import("@stellar/stellar-sdk").Transaction<import("@stellar/stellar-sdk").Memo<import("@stellar/stellar-sdk").MemoType>, import("@stellar/stellar-sdk").Operation[]>>;
     estimateTransactionFee: () => Promise<AssetValue>;
@@ -19,6 +19,6 @@ export declare function getStellarToolbox(params?: StellarToolboxParams): {
     signTransaction: (transaction: {
         toXDR: () => string;
     }) => Promise<import("@stellar/stellar-sdk").Transaction<import("@stellar/stellar-sdk").Memo<import("@stellar/stellar-sdk").MemoType>, import("@stellar/stellar-sdk").Operation[]> | import("@stellar/stellar-sdk").FeeBumpTransaction>;
-    transfer: ({ recipient, assetValue, memo }: StellarTransferParams) => Promise<string>;
+    transfer: ({ recipient, assetValue, memo, sweep }: StellarTransferParams) => Promise<string>;
     validateAddress: typeof validateStellarAddress;
 };

package/dist/types/sui/toolbox.d.ts

@@ -7,7 +7,7 @@ export declare function getSuiToolbox({ provider: providerParam, ...signerParams
         bytes: string;
         signature: string;
     }) => Promise<string>;
-    createTransaction: ({ recipient, assetValue, gasBudget, sender }: SuiCreateTransactionParams) => Promise<{
+    createTransaction: ({ recipient, assetValue, gasBudget, sender, sweep }: SuiCreateTransactionParams) => Promise<{
         tx: Transaction;
         txBytes: Uint8Array<ArrayBuffer>;
     }>;
@@ -15,13 +15,13 @@ export declare function getSuiToolbox({ provider: providerParam, ...signerParams
     getAddress: () => Promise<string>;
     getBalance: (targetAddress?: string) => Promise<AssetValue[]>;
     signAndBroadcastTransaction: (transaction: Transaction | Uint8Array<ArrayBuffer> | string) => Promise<string>;
-    signTransaction: (params: Uint8Array<ArrayBuffer> | SuiCreateTransactionParams | Awaited<ReturnType<({ recipient, assetValue, gasBudget, sender }: SuiCreateTransactionParams) => Promise<{
+    signTransaction: (params: Uint8Array<ArrayBuffer> | SuiCreateTransactionParams | Awaited<ReturnType<({ recipient, assetValue, gasBudget, sender, sweep }: SuiCreateTransactionParams) => Promise<{
         tx: Transaction;
         txBytes: Uint8Array<ArrayBuffer>;
     }>>>) => Promise<{
         bytes: string;
         signature: string;
     } | import("@mysten/sui/cryptography").SignatureWithBytes>;
-    transfer: ({ assetValue, gasBudget, recipient }: SuiTransferParams) => Promise<string>;
+    transfer: ({ assetValue, gasBudget, recipient, sweep }: SuiTransferParams) => Promise<string>;
     validateAddress: typeof validateSuiAddress;
 };

package/dist/types/ton/toolbox.d.ts

@@ -5,7 +5,6 @@ export declare function getTONToolbox(toolboxParams?: TONToolboxParams): {
     broadcastTransaction: (transferCell: Cell) => Promise<string>;
     createTransaction: ({ sender, sweep, ...params }: GenericTransferParams & {
         sender?: string;
-        sweep?: boolean;
     }) => Promise<TONToolboxTransaction>;
     estimateTransactionFee: ({ sender, ...params }: GenericTransferParams & {
         sender?: string;
@@ -18,9 +17,7 @@ export declare function getTONToolbox(toolboxParams?: TONToolboxParams): {
     }) => Promise<Address>;
     sign: (transactionInput: TONTransactionInput) => Promise<Cell>;
     signAndBroadcastTransaction: (transaction: TONTransactionInput) => Promise<string>;
-    transfer: ({ assetValue, recipient, memo, sweep }: GenericTransferParams & {
-        sweep?: boolean;
-    }) => Promise<string>;
+    transfer: ({ assetValue, recipient, memo, sweep }: GenericTransferParams) => Promise<string>;
     validateAddress: typeof validateTonAddress;
 };
 export declare function validateTonAddress(address: string): boolean;

package/dist/types/tron/toolbox.d.ts

@@ -13,7 +13,7 @@ export declare function getTronPrivateKeyFromMnemonic({ phrase, derivationPath:
 export declare function getTronToolbox(options?: TronToolboxOptions): {
     approve: ({ assetAddress, spenderAddress, amount, from }: TronApproveParams) => Promise<string>;
     broadcastTransaction: typeof broadcastTronTransaction;
-    createTransaction: ({ recipient, assetValue, memo, sender, expiration }: TronCreateTransactionParams) => Promise<TronTransaction>;
+    createTransaction: ({ recipient, assetValue, memo, sender, expiration, sweep, }: TronCreateTransactionParams) => Promise<TronTransaction>;
     estimateTransactionFee: ({ assetValue, memo, recipient, sender, }: TronTransferParams & {
         sender?: string;
     }) => Promise<AssetValue>;
@@ -24,6 +24,6 @@ export declare function getTronToolbox(options?: TronToolboxOptions): {
     isApproved: ({ assetAddress, spenderAddress, from, amount }: TronIsApprovedParams) => Promise<boolean>;
     signAndBroadcastTransaction: (transaction: TronTransaction) => Promise<string>;
     signTransaction: (transaction: TronTransaction) => Promise<import("./types").TronSignedTransaction>;
-    transfer: ({ recipient, assetValue, memo, expiration }: TronTransferParams) => Promise<string>;
+    transfer: ({ recipient, assetValue, memo, expiration, sweep }: TronTransferParams) => Promise<string>;
     validateAddress: typeof isValidTronAddress;
 };

package/dist/types/utxo/helpers/coinselect.d.ts

@@ -6,9 +6,10 @@ type AccumulativeParams<T extends UTXOSizeInput> = {
     feeRate: number;
     chain: UTXOChain;
     changeAddress?: string;
+    sweep?: boolean;
 };
 export declare function getDustThreshold(chain: UTXOChain): 550 | 5500 | 100000 | 546;
-export declare function accumulative<T extends UTXOSizeInput>({ inputs, outputs, feeRate, chain, changeAddress, }: AccumulativeParams<T>): {
+export declare function accumulative<T extends UTXOSizeInput>({ inputs, outputs, feeRate, chain, changeAddress, sweep, }: AccumulativeParams<T>): {
     fee: number;
     inputs: T[];
     outputs: TargetOutput[];