@swapkit/toolboxes 4.19.0 → 4.20.1

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

@@ -33,11 +33,79 @@ export declare function OPToolbox({ provider, ...toolboxSignerParams }: EVMToolb
     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<import("ethers").ContractTransaction>;
+    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<import("ethers").ContractTransaction>;
-    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
-    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    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, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => 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;
+    }>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => 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;
+    }>;
     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 & {

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

@@ -1,6 +1,6 @@
 import type { AssetValue, ChainSigner, DerivationPathArray, FeeOption, GenericCreateTransactionParams, GenericTransferParams } from "@swapkit/helpers";
 import { Chain } from "@swapkit/helpers";
-import type { BigNumberish, BrowserProvider, JsonFragment, JsonRpcSigner, Provider, Signer, Transaction, TypedDataField } from "ethers";
+import type { 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, HYPEREVMToolbox, LINEAToolbox, MATICToolbox, MEGAETHToolbox, MONADToolbox, OPToolbox, PLASMAToolbox, SONICToolbox, UNIToolbox, XLayerToolbox } from "./toolbox";
 export declare enum EthNetwork {
@@ -30,7 +30,7 @@ export type CallParams = {
     abi: readonly JsonFragment[];
     funcName: string;
     funcParams?: unknown[];
-    txOverrides?: Partial<Transaction>;
+    txOverrides?: TransactionRequest;
     feeOption?: FeeOption;
 };
 export type EstimateCallParams = Pick<CallParams, "contractAddress" | "abi" | "funcName" | "funcParams" | "txOverrides">;
@@ -54,9 +54,9 @@ export type EVMMaxSendableAmountsParams = {
     funcName?: string;
     contractAddress?: string;
     funcParams?: unknown[];
-    txOverrides?: Partial<Transaction>;
+    txOverrides?: TransactionRequest;
 };
-export type EVMTxBaseParams<T = bigint> = {
+export type EVMTxBaseParams<T = BigNumberish> = {
     to?: string;
     from?: string;
     nonce?: number;
@@ -65,12 +65,12 @@ export type EVMTxBaseParams<T = bigint> = {
     value?: T;
     chainId?: T;
 };
-export type EIP1559TxParams<T = bigint> = EVMTxBaseParams<T> & {
+export type EIP1559TxParams<T = BigNumberish> = EVMTxBaseParams<T> & {
     type?: number;
     maxFeePerGas?: T;
     maxPriorityFeePerGas?: T;
 };
-export type LegacyEVMTxParams<T = bigint> = EVMTxBaseParams<T> & {
+export type LegacyEVMTxParams<T = BigNumberish> = EVMTxBaseParams<T> & {
     gasPrice?: T;
 };
 export type { Authorization, TypedDataDomain, TypedDataField } from "ethers";
@@ -86,7 +86,7 @@ export interface EIP712TypedData {
     primaryType: string;
     types: Record<string, TypedDataField[]>;
 }
-export type EIP7702TxParams<T = bigint> = EIP1559TxParams<T> & {
+export type EIP7702TxParams<T = BigNumberish> = EIP1559TxParams<T> & {
     type?: 4;
     authorizations?: import("ethers").Authorization[];
 };

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

@@ -1,5 +1,4 @@
 import type { Account, Contract } from "@near-js/accounts";
-import { 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";
@@ -22,7 +21,7 @@ export declare function getNearToolbox(toolboxParams?: NearToolboxParams): {
     getAddress: () => Promise<string>;
     getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
     getGasPrice: () => Promise<string>;
-    getNearProvider: () => Promise<JsonRpcProvider>;
+    getNearProvider: () => Promise<import("@near-js/providers").JsonRpcProvider>;
     getPublicKey: () => Promise<string>;
     getSignerFromPhrase: typeof getNearSignerFromPhrase;
     getSignerFromPrivateKey: typeof getNearSignerFromPrivateKey;

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

@@ -1,4 +1,4 @@
-import { GatewayApiClient } from "@radixdlt/babylon-gateway-api-sdk";
+import type { GatewayApiClient } from "@radixdlt/babylon-gateway-api-sdk";
 import { AssetValue, type SKConfigIntegrations } from "@swapkit/helpers";
 export type RadixWallet = ReturnType<typeof getRadixToolbox>;
 export declare function validateRadixAddress(address: string): boolean;
@@ -7,7 +7,7 @@ export declare function getRadixToolbox({ dappConfig }?: {
 }): {
     getAddress: () => string;
     getBalance: (address: string) => Promise<AssetValue[]>;
-    networkApi: GatewayApiClient;
+    getNetworkApi: () => Promise<GatewayApiClient>;
     signAndBroadcast: (params: any) => Promise<string>;
     validateAddress: typeof validateRadixAddress;
 };

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

@@ -1,10 +1,9 @@
 import { AssetValue, type ChainSigner, type GenericTransferParams } from "@swapkit/helpers";
-import type { Transaction as RippleTransaction } from "xrpl";
-import { type Payment } from "xrpl";
+import type { Payment, Transaction as RippleTransaction } from "xrpl";
 export * from "./currency";
 export * from "./tokens";
 export type RippleWallet = ReturnType<typeof getRippleToolbox>;
-export { hashes, type Transaction as RippleTransaction } from "xrpl";
+export type { Transaction as RippleTransaction } from "xrpl";
 export declare const XRPL_TOKEN_ERROR_CODES: {
     readonly tecFROZEN: "tecFROZEN";
     readonly tecNO_AUTH: "tecNO_AUTH";
@@ -65,7 +64,7 @@ export declare function getRippleToolbox(params?: RippleToolboxParams): {
     }) => Promise<Payment>;
     disconnect: () => void;
     estimateTransactionFee: () => Promise<AssetValue>;
-    getAddress: () => string | Promise<string>;
+    getAddress: () => Promise<string>;
     getBalance: (checkAddress?: string) => Promise<AssetValue[]>;
     getTrustLines: (address?: string) => Promise<TrustLineInfo[]>;
     hasTrustLine: ({ address, currency, issuer, }: {
@@ -76,10 +75,7 @@ export declare function getRippleToolbox(params?: RippleToolboxParams): {
     setTrustLine: ({ currency, issuer, limit, sender }: TrustLineParams) => Promise<RippleTransaction>;
     setTrustLineAndBroadcast: (params: TrustLineParams) => Promise<string>;
     signAndBroadcastTransaction: (tx: RippleTransaction) => Promise<string>;
-    signTransaction: (tx: RippleTransaction) => {
-        tx_blob: string;
-        hash: string;
-    } | Promise<{
+    signTransaction: (tx: RippleTransaction) => Promise<{
         tx_blob: string;
         hash: string;
     }>;

package/dist/types/substrate/substrate.d.ts

@@ -1,4 +1,4 @@
-import { ApiPromise } from "@polkadot/api";
+import type { ApiPromise } from "@polkadot/api";
 import type { SubmittableExtrinsic } from "@polkadot/api/types";
 import type { KeyringPair } from "@polkadot/keyring/types";
 import type { Callback, IKeyringPair, ISubmittableResult, Signer } from "@polkadot/types/types";

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

@@ -1,12 +1,12 @@
 import { AssetValue, type GenericTransferParams } from "@swapkit/helpers";
-import { Address, Cell } from "@ton/ton";
-import type { TONToolboxParams, TONTransactionMessage } from "./types";
+import { Address, Cell } from "@ton/core";
+import type { TONToolboxParams, TONToolboxTransaction, TONTransactionInput } from "./types";
 export declare function getTONToolbox(toolboxParams?: TONToolboxParams): {
     broadcastTransaction: (transferCell: Cell) => Promise<string>;
-    createTransaction: ({ sender, ...params }: GenericTransferParams & {
+    createTransaction: ({ sender, sweep, ...params }: GenericTransferParams & {
         sender?: string;
         sweep?: boolean;
-    }) => Promise<TONTransactionMessage[]>;
+    }) => Promise<TONToolboxTransaction>;
     estimateTransactionFee: ({ sender, ...params }: GenericTransferParams & {
         sender?: string;
     }) => Promise<AssetValue>;
@@ -16,8 +16,8 @@ export declare function getTONToolbox(toolboxParams?: TONToolboxParams): {
         jettonMasterAddress: string;
         ownerAddress: string;
     }) => Promise<Address>;
-    sign: (messages: TONTransactionMessage[]) => Promise<Cell>;
-    signAndBroadcastTransaction: (messages: TONTransactionMessage[]) => Promise<string>;
+    sign: (transactionInput: TONTransactionInput) => Promise<Cell>;
+    signAndBroadcastTransaction: (transaction: TONTransactionInput) => Promise<string>;
     transfer: ({ assetValue, recipient, memo, sweep }: GenericTransferParams & {
         sweep?: boolean;
     }) => Promise<string>;

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

@@ -20,4 +20,9 @@ export type TONTransactionMessage = {
     stateInit?: string;
     sendMode?: number;
 };
+export type TONToolboxTransaction = {
+    messages: TONTransactionMessage[];
+    sendMode: number;
+};
+export type TONTransactionInput = TONToolboxTransaction | TONTransactionMessage[];
 export type TONWallet = ReturnType<typeof getTONToolbox>;

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

@@ -1,4 +1,4 @@
-export { getTronPrivateKeyFromMnemonic, getTronToolbox, validateTronAddress, } from "./toolbox";
-export type { TronApprovedParams, TronApproveParams, TronCreateTransactionParams, TronIsApprovedParams, TronSignedTransaction, TronSigner, TronToolboxOptions, TronTransaction, TronTransferParams, } from "./types";
+export { getTronPrivateKeyFromMnemonic, getTronToolbox, validateTronAddress, withTronTransactionData, withTronTransactionValue, } from "./toolbox";
+export type { TronApprovedParams, TronApproveParams, TronCreateTransactionParams, TronIsApprovedParams, TronSignedTransaction, TronSigner, TronToolboxOptions, TronTransaction, TronTransactionMetadata, TronTransactionWithMetadata, TronTransferParams, } from "./types";
 import type { getTronToolbox } from "./toolbox";
 export type TronWallet = ReturnType<typeof getTronToolbox>;

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

@@ -1,8 +1,10 @@
 import { AssetValue } from "@swapkit/helpers";
 import { broadcastTronTransaction } from "./helpers/trongrid";
 import { isValidTronAddress } from "./helpers/utils";
-import type { TronApprovedParams, TronApproveParams, TronCreateTransactionParams, TronIsApprovedParams, TronToolboxOptions, TronTransaction, TronTransferParams } from "./types";
+import type { TronApprovedParams, TronApproveParams, TronCreateTransactionParams, TronIsApprovedParams, TronToolboxOptions, TronTransaction, TronTransactionWithMetadata, TronTransferParams } from "./types";
 export declare const validateTronAddress: typeof isValidTronAddress;
+export declare function withTronTransactionValue<TTransaction extends TronTransaction>(transaction: TTransaction, value: string | number | bigint): TTransaction & Required<Pick<TronTransactionWithMetadata, "value">>;
+export declare function withTronTransactionData<TTransaction extends TronTransaction>(transaction: TTransaction, data?: string): TTransaction & Pick<TronTransactionWithMetadata, "data">;
 export declare function getTronPrivateKeyFromMnemonic({ phrase, derivationPath: customPath, index, }: {
     phrase: string;
     derivationPath?: string;

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

@@ -24,6 +24,11 @@ export interface TronTransaction {
         contractRet?: string;
     }>;
 }
+export type TronTransactionMetadata = {
+    data?: string;
+    value?: string;
+};
+export type TronTransactionWithMetadata = TronTransaction & TronTransactionMetadata;
 export interface TronSignedTransaction extends TronTransaction {
     signature: string[];
 }

package/package.json

@@ -1,5 +1,5 @@
 {
-  "dependencies": { "@swapkit/helpers": "4.15.1", "@swapkit/utxo-signer": "2.2.2" },
+  "dependencies": { "@swapkit/helpers": "4.15.3", "@swapkit/utxo-signer": "2.2.2" },
   "description": "SwapKit - Toolboxes",
   "devDependencies": {
     "@aptos-labs/ts-sdk": "7.0.1",
@@ -49,6 +49,7 @@
     "micro-key-producer": "0.8.6",
     "near-seed-phrase": "0.2.1",
     "protobufjs": "8.0.3",
+    "ripple-address-codec": "5.0.1",
     "starknet": "10.0.2",
     "ts-pattern": "5.9.0",
     "xrpl": "4.6.0"
@@ -182,6 +183,7 @@
     "micro-key-producer": "0.8.6",
     "near-seed-phrase": "0.2.1",
     "protobufjs": "8.0.3",
+    "ripple-address-codec": "5.0.1",
     "starknet": "10.0.2",
     "ts-pattern": "5.9.0",
     "xrpl": "4.6.0"
@@ -196,5 +198,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "4.19.0"
+  "version": "4.20.1"
 }