@swapkit/toolboxes 4.23.1 → 4.25.0

package/dist/types/aleo/types.d.ts

@@ -0,0 +1,32 @@
+import type { ChainSigner, DerivationPathArray, GenericCreateTransactionParams, GenericTransferParams } from "@swapkit/helpers";
+import type { getAleoToolbox } from "./toolbox";
+export type AleoWallet = ReturnType<typeof getAleoToolbox>;
+export type AleoChainSigner = ChainSigner<AleoUnsignedTransaction, AleoTransaction>;
+export type AleoToolboxParams = {
+    phrase?: string;
+    derivationPath?: DerivationPathArray;
+} | {
+    signer?: AleoChainSigner;
+};
+export type AleoCreateTransactionParams = Omit<GenericCreateTransactionParams, "feeRate"> & {
+    priorityFee?: number;
+};
+export type AleoTransferParams = Omit<GenericTransferParams, "feeRate"> & {
+    priorityFee?: number;
+};
+export type AleoTransaction = string | {
+    toString: () => string;
+};
+export type AleoRecord = {
+    microcredits: bigint;
+    plaintext: string;
+    spent: boolean;
+    transactionId: string;
+};
+export type AleoUnsignedTransaction = {
+    functionName: string;
+    inputs: [string, string];
+    priorityFee: number;
+    programName: string;
+    sender: string;
+};

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

@@ -3,18 +3,22 @@ import type { AptosCreateTransactionParams, AptosExtensionProvider, AptosToolbox
 export declare function validateAptosAddress(address: string): boolean;
 export declare function getAptosToolbox({ derivationPath, provider: providerParam, ...signerParams }?: AptosToolboxParams): {
     broadcastTransaction: ({ senderAuthenticator, transaction, }: {
-        senderAuthenticator: Awaited<ReturnType<(transaction: Awaited<ReturnType<({ recipient, assetValue, maxGasAmount, sender: _senderAddress, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>>>) => Promise<import("@aptos-labs/ts-sdk").AccountAuthenticator>>>;
-        transaction: Awaited<ReturnType<({ recipient, assetValue, maxGasAmount, sender: _senderAddress, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>>>;
+        senderAuthenticator: Awaited<ReturnType<(transaction: Awaited<ReturnType<({ recipient, assetValue, maxGasAmount, sender: _senderAddress, sweep, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>>>) => Promise<import("@aptos-labs/ts-sdk").AccountAuthenticator>>>;
+        transaction: Awaited<ReturnType<({ recipient, assetValue, maxGasAmount, sender: _senderAddress, sweep, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>>>;
     }) => Promise<string>;
-    createTransaction: ({ recipient, assetValue, maxGasAmount, sender: _senderAddress, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>;
+    createTransaction: ({ recipient, assetValue, maxGasAmount, sender: _senderAddress, sweep, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>;
     estimateTransactionFee: (params?: AptosCreateTransactionParams) => Promise<AssetValue>;
     getAddress: () => Promise<"" | `0x${string}`>;
     getBalance: (targetAddress?: string) => Promise<AssetValue[]>;
-    signAndBroadcastTransaction: (transaction: Awaited<ReturnType<({ recipient, assetValue, maxGasAmount, sender: _senderAddress, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>>>) => Promise<string>;
-    signTransaction: (transaction: Awaited<ReturnType<({ recipient, assetValue, maxGasAmount, sender: _senderAddress, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>>>) => Promise<import("@aptos-labs/ts-sdk").AccountAuthenticator>;
-    transfer: ({ assetValue, maxGasAmount, recipient }: AptosTransferParams) => Promise<string>;
+    signAndBroadcastTransaction: (transaction: Awaited<ReturnType<({ recipient, assetValue, maxGasAmount, sender: _senderAddress, sweep, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>>>) => Promise<string>;
+    signTransaction: (transaction: Awaited<ReturnType<({ recipient, assetValue, maxGasAmount, sender: _senderAddress, sweep, }: AptosCreateTransactionParams) => Promise<import("@aptos-labs/ts-sdk").SimpleTransaction>>>) => Promise<import("@aptos-labs/ts-sdk").AccountAuthenticator>;
+    transfer: ({ assetValue, maxGasAmount, recipient, sweep }: AptosTransferParams) => Promise<string>;
     validateAddress: typeof validateAptosAddress;
 };
+/**
+ * Extension wallets control gas parameters themselves, so the fee reserve for a native sweep cannot
+ * be computed at build time, and this factory has no Aptos client for token balance lookups.
+ */
 export declare function createAptosExtensionTransfer({ provider }: {
     provider: AptosExtensionProvider;
-}): ({ assetValue, recipient }: AptosTransferParams) => Promise<string>;
+}): ({ assetValue, recipient, sweep }: AptosTransferParams) => Promise<string>;

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

@@ -14,7 +14,7 @@ export declare function getCardanoToolbox(toolboxParams?: {
     index?: number;
     derivationPath?: DerivationPathArray;
 }): {
-    createTransaction: ({ sender, recipient, assetValue, memo, pureLovelaceOnly, }: CardanoCreateTransactionParams) => Promise<{
+    createTransaction: ({ sender, recipient, assetValue, memo, pureLovelaceOnly, sweep, }: CardanoCreateTransactionParams) => Promise<{
         tx: Transaction;
         unsignedTx: string;
     }>;
@@ -23,7 +23,7 @@ export declare function getCardanoToolbox(toolboxParams?: {
     getBalance: (addressParam?: string) => Promise<AssetValue[]>;
     signAndBroadcastTransaction: (txInput: string) => Promise<string>;
     signTransaction: (tx: string) => Promise<string>;
-    transfer: ({ recipient, assetValue, memo }: CardanoTransferParams) => Promise<string>;
+    transfer: ({ recipient, assetValue, memo, sweep }: CardanoTransferParams) => Promise<string>;
     validateAddress: typeof validateCardanoAddress;
 };
 export type CardanoWallet = ReturnType<typeof getCardanoToolbox>;

package/dist/types/cosmos/thorchainUtils/messages.d.ts

@@ -86,7 +86,7 @@ export declare function createTransaction(params: ThorchainCreateTransactionPara
         };
     })[];
     sequence: number;
-}> | Promise<{
+} | {
     accountNumber: number;
     chainId: import("@swapkit/types").ChainId.Maya | import("@swapkit/types").ChainId.THORChain;
     fee: {
@@ -110,6 +110,7 @@ export declare function createTransaction(params: ThorchainCreateTransactionPara
     })[];
     sequence: number;
 }>;
+export declare function resolveThorchainSweepAssetValue({ assetValue, sender, }: Pick<ThorchainCreateTransactionParams, "assetValue" | "sender">): Promise<AssetValue>;
 export declare function buildTransferTx({ sender, recipient, assetValue, memo, asSignable, asAminoMessage, sequence, accountNumber, }: ThorchainCreateTransactionParams): Promise<{
     accountNumber: number;
     chainId: import("@swapkit/types").ChainId.Maya | import("@swapkit/types").ChainId.THORChain;

package/dist/types/cosmos/thorchainUtils/registry.d.ts

@@ -1,3 +1,3 @@
 import { type TCLikeChain } from "@swapkit/helpers";
 export declare function createDefaultRegistry(): Promise<import("@cosmjs/proto-signing/build").Registry>;
-export declare function createDefaultAminoTypes(chain: TCLikeChain): Promise<import("@cosmjs/stargate/build").AminoTypes>;
+export declare function createDefaultAminoTypes(chain: TCLikeChain, addressPrefix?: string): Promise<import("@cosmjs/stargate/build").AminoTypes>;

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

@@ -47,7 +47,7 @@ export declare function createCosmosToolbox({ chain, ...toolboxParams }: CosmosT
     getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
     signAndBroadcastTransaction: (transaction: CosmosTransaction) => Promise<string>;
     signTransaction: (transaction: CosmosTransaction) => Promise<TxRaw>;
-    transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: GenericTransferParams) => Promise<string>;
+    transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, sweep, }: GenericTransferParams) => Promise<string>;
     validateAddress: (address: string) => boolean;
     verifySignature: ({ signature, message, address, }: {
         signature: string;

package/dist/types/cosmos/toolbox/thorchain.d.ts

@@ -1,5 +1,5 @@
 import type { Pubkey, Secp256k1HdWallet } from "@cosmjs/amino";
-import { type GenericTransferParams, SwapKitNumber, type TCLikeChain } from "@swapkit/helpers";
+import { type GenericTransferParams, type TCLikeChain } from "@swapkit/helpers";
 import type { CosmosTransaction } from "@swapkit/helpers/api";
 import { buildEncodedTxBody, createDefaultRegistry, createTransaction, parseAminoMessageForDirectSigning } from "../thorchainUtils";
 import type { CosmosToolboxParams, MultiSigSigner, MultisigTx } from "../types";
@@ -63,13 +63,13 @@ export declare function createThorchainToolbox({ chain, ...toolboxParams }: Cosm
     createDefaultRegistry: typeof createDefaultRegistry;
     createMultisig: typeof createMultisig;
     createTransaction: typeof createTransaction;
-    deposit: ({ assetValue, memo, recipient, }: Omit<GenericTransferParams, "recipient"> & {
+    deposit: ({ assetValue, memo, recipient, sweep, }: Omit<GenericTransferParams, "recipient"> & {
         recipient?: string;
     }) => Promise<string>;
     getFees: () => Promise<{
-        average: SwapKitNumber;
-        fast: SwapKitNumber;
-        fastest: SwapKitNumber;
+        average: import("@swapkit/helpers").SwapKitNumber;
+        fast: import("@swapkit/helpers").SwapKitNumber;
+        fastest: import("@swapkit/helpers").SwapKitNumber;
     }>;
     importSignature: typeof importSignature;
     parseAminoMessageForDirectSigning: typeof parseAminoMessageForDirectSigning;
@@ -85,7 +85,7 @@ export declare function createThorchainToolbox({ chain, ...toolboxParams }: Cosm
     }>;
     signTransaction: (transaction: CosmosTransaction) => Promise<import("cosmjs-types/cosmos/tx/v1beta1/tx").TxRaw>;
     signWithPrivateKey: typeof signWithPrivateKey;
-    transfer: ({ assetValue, memo, recipient, }: Omit<GenericTransferParams, "recipient"> & {
+    transfer: ({ assetValue, memo, recipient, sweep, }: Omit<GenericTransferParams, "recipient"> & {
         recipient?: string;
     }) => Promise<string>;
     createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;

package/dist/types/cosmos/util.d.ts

@@ -1,6 +1,6 @@
 import type { OfflineSigner } from "@cosmjs/proto-signing";
 import type { SigningStargateClientOptions } from "@cosmjs/stargate";
-import { AssetValue, type CosmosChain } from "@swapkit/helpers";
+import { AssetValue, type CosmosChain, SwapKitNumber, type TCLikeChain } from "@swapkit/helpers";
 import type { CosmosCreateTransactionParams } from "./types";
 export declare const USK_KUJIRA_FACTORY_DENOM = "FACTORY/KUJIRA1QK00H5ATUTPSV900X202PXX42NPJR9THG58DNQPA72F2P7M2LUASE444A7/UUSK";
 export declare const YUM_KUJIRA_FACTORY_DENOM = "FACTORY/KUJIRA1YGFXN0ER40KLCNCK8THLTUPRDXLCK6WVNPKF2K/UYUM";
@@ -32,6 +32,7 @@ export declare function getDefaultChainFee(chain: CosmosChain): {
     }[];
     gas: string;
 };
+export declare function getThorchainNativeFee(chain: TCLikeChain): Promise<SwapKitNumber>;
 export declare const getMsgSendDenom: (symbol: string, isThorchain?: boolean) => string;
 export declare const getDenomWithChain: ({ symbol, chain }: AssetValue) => string;
 export declare function createStargateClient(url: string): Promise<import("@cosmjs/stargate/build").StargateClient>;
@@ -40,7 +41,7 @@ export declare function createOfflineStargateClient(wallet: OfflineSigner, regis
 /**
  * Used to build tx for Cosmos and Kujira
  */
-export declare function cosmosCreateTransaction({ sender, recipient, assetValue, memo, feeRate, sequence, accountNumber, }: CosmosCreateTransactionParams): Promise<{
+export declare function cosmosCreateTransaction({ sender, recipient, assetValue, memo, feeRate, sequence, accountNumber, sweep, }: CosmosCreateTransactionParams): Promise<{
     accountNumber: number;
     chainId: import("@swapkit/types").ChainId;
     fee: {
@@ -64,6 +65,19 @@ export declare function cosmosCreateTransaction({ sender, recipient, assetValue,
     }[];
     sequence: number;
 }>;
+export declare function getFeeAmountForDenom(fees: readonly {
+    amount: string;
+    denom: string;
+}[], denom: string): bigint;
+export declare function getSweepAssetValue({ assetValue, balances, denom, feeAmount, }: {
+    assetValue: AssetValue;
+    balances: readonly {
+        amount: string;
+        denom: string;
+    }[];
+    denom: string;
+    feeAmount?: bigint;
+}): AssetValue;
 /**
  * Converts a Cosmos denom and amount to an AssetValue with proper decimal handling
  * @param denom - The denomination string

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

@@ -1,16 +1,28 @@
 import { type Asset, AssetValue, type ChainSigner, type EVMChain, FeeOption } from "@swapkit/helpers";
-import { BrowserProvider, Contract, type ContractTransaction, type Fragment, type HDNodeWallet, type JsonFragment, type JsonRpcSigner, type Provider, type Signer } from "ethers";
+import { BrowserProvider, Contract, type ContractTransaction, type Fragment, type HDNodeWallet, type JsonFragment, type JsonRpcSigner, type Provider, type Signer, type TransactionRequest } from "ethers";
 import type { ApproveParams, CallParams, EIP1559TxParams, EstimateCallParams, EVMCreateTransactionParams, EVMTransferParams, EVMTxParams, IsApprovedParams, SignTypedDataParams } from "../types";
+type GasPrices = {
+    [key in FeeOption]: {
+        gasPrice?: bigint;
+        l1GasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    };
+};
 type ToolboxWrapParams<P = Provider | BrowserProvider, T = {}> = T & {
+    estimateGasPrices?: () => Promise<GasPrices>;
+    estimateAdditionalFee?: (tx: TransactionRequest) => Promise<bigint | undefined>;
     isEIP1559Compatible?: boolean;
     provider: P;
     signer?: Signer;
     chain: EVMChain;
 };
 export declare const MAX_APPROVAL: bigint;
-export declare function BaseEVMToolbox<P extends Provider | BrowserProvider, S extends (ChainSigner<EVMTransferParams, string> & Signer) | JsonRpcSigner | HDNodeWallet | undefined>({ chain, provider, signer, isEIP1559Compatible, }: {
+export declare function BaseEVMToolbox<P extends Provider | BrowserProvider, S extends (ChainSigner<EVMTransferParams, string> & Signer) | JsonRpcSigner | HDNodeWallet | undefined>({ chain, provider, signer, isEIP1559Compatible, estimateGasPrices: estimateGasPricesOverride, estimateAdditionalFee, }: {
     signer: S;
     provider: P;
+    estimateGasPrices?: () => Promise<GasPrices>;
+    estimateAdditionalFee?: (tx: TransactionRequest) => Promise<bigint | undefined>;
     isEIP1559Compatible?: boolean;
     chain?: EVMChain;
 }): {
@@ -55,7 +67,29 @@ export declare function BaseEVMToolbox<P extends Provider | BrowserProvider, S e
         blockTag?: import("ethers").BlockTag;
         enableCcipRead?: boolean;
     }>;
-    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: EVMCreateTransactionParams) => Promise<{
+    createTransaction: ({ assetValue, authorizations, memo, recipient, data, feeOptionKey, gasLimit, sender: fromOverride, sweep, type, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: 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;
@@ -73,7 +107,29 @@ export declare function BaseEVMToolbox<P extends Provider | BrowserProvider, S e
         blockTag?: import("ethers").BlockTag;
         enableCcipRead?: boolean;
     }>;
-    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: EVMCreateTransactionParams) => Promise<{
+    createTransferTx: ({ assetValue, authorizations, memo, recipient, data, feeOptionKey, gasLimit, sender: fromOverride, sweep, type, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: 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;
@@ -100,12 +156,7 @@ export declare function BaseEVMToolbox<P extends Provider | BrowserProvider, S e
         txOverrides?: EVMTxParams;
         data?: string;
     }) => Promise<bigint>;
-    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
-        l1GasPrice?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-    }; }>;
+    estimateGasPrices: () => Promise<GasPrices>;
     estimateTransactionFee: ({ feeOption, ...txObject }: EIP1559TxParams & {
         feeOption: FeeOption;
     }) => Promise<AssetValue>;
@@ -113,8 +164,9 @@ export declare function BaseEVMToolbox<P extends Provider | BrowserProvider, S e
     getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
     getNetworkParams: () => import("@swapkit/helpers").NetworkParams | undefined;
     isApproved: ({ assetAddress, spenderAddress, from, amount }: IsApprovedParams) => Promise<boolean>;
-    sendTransaction: ({ feeOptionKey, ...tx }: EVMTxParams & {
+    sendTransaction: ({ feeOptionKey, sweep, ...tx }: EVMTxParams & {
         feeOptionKey?: FeeOption;
+        sweep?: boolean;
     }) => Promise<string>;
     signAuthorization: ((params: {
         address: string;
@@ -123,7 +175,7 @@ export declare function BaseEVMToolbox<P extends Provider | BrowserProvider, S e
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
     signTypedData: (({ domain, types, value }: SignTypedDataParams) => Promise<string>) | undefined;
-    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: EVMTransferParams) => Promise<string>;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: EVMTransferParams) => Promise<string>;
     validateAddress: typeof validateEVMAddress;
 };
 export declare function validateEVMAddress(address: string): boolean;
@@ -135,7 +187,7 @@ export declare function isStateChangingCall({ abi, funcName }: {
     funcName: string;
 }): any;
 export declare function toChecksumAddress(address: string): string;
-export declare function getEIP1193SendTransaction(provider: Provider | BrowserProvider): ({ value, ...params }: EVMTxParams | ContractTransaction) => Promise<string>;
+export declare function getEIP1193SendTransaction(provider: Provider | BrowserProvider, includeGasFields?: boolean): ({ value, ...params }: EVMTxParams | ContractTransaction) => Promise<string>;
 export declare function getChecksumAddressFromAsset(asset: Asset, chain: EVMChain): string;
 export declare const ContractAddress: Record<EVMChain, string>;
 export declare function getTokenAddress({ chain, symbol, ticker }: Asset, baseAssetChain: EVMChain): string | null;
@@ -161,14 +213,7 @@ export declare function getEstimateGasPrices({ chain, provider, isEIP1559Compati
     provider: Provider;
     isEIP1559Compatible?: boolean;
     chain: EVMChain;
-}): () => Promise<{
-    [key in FeeOption]: {
-        l1GasPrice?: bigint;
-        gasPrice?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-    };
-}>;
+}): () => Promise<GasPrices>;
 export declare const isEIP7702Transaction: (tx: EVMTxParams) => boolean;
 export declare const isEIP1559Transaction: (tx: EVMTxParams) => boolean;
 type EVMTxType = "eip7702" | "eip1559" | "legacy";