@swapkit/toolboxes 5.2.1 → 5.4.0

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

@@ -7,9 +7,9 @@ export declare function ETHToolbox(params: EVMToolboxParams): {
     }[], multicallAddress?: string, funcName?: string, feeOptionKey?: FeeOption) => Promise<string>;
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -179,9 +179,9 @@ export declare function ETHToolbox(params: EVMToolboxParams): {
 export declare const ADIToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -351,9 +351,181 @@ export declare const ADIToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
 export declare const ARBToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: 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<import("ethers").Authorization>;
+        customData?: any;
+        blockTag?: import("ethers").BlockTag;
+        enableCcipRead?: boolean;
+    }>;
+    createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").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<import("ethers").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<import("ethers").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<import("ethers").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: {
+            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;
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
+    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<import("ethers").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 ARCToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
+    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>;
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -523,9 +695,9 @@ export declare const ARBToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
 export declare const AURORAToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -695,9 +867,9 @@ export declare const AURORAToolbox: ({ provider, ...toolboxParams }: EVMToolboxP
 export declare const AVAXToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -874,9 +1046,9 @@ export declare const BASEToolbox: ({ provider, ...toolboxSignerParams }: EVMTool
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -1045,9 +1217,9 @@ export declare const BASEToolbox: ({ provider, ...toolboxSignerParams }: EVMTool
 export declare const BERAToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -1217,9 +1389,9 @@ export declare const BERAToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
 export declare const BSCToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -1389,9 +1561,9 @@ export declare const BSCToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
 export declare const BotanixToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -1561,9 +1733,9 @@ export declare const BotanixToolbox: ({ provider, ...toolboxParams }: EVMToolbox
 export declare const COREToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -1733,9 +1905,9 @@ export declare const COREToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
 export declare const CORNToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -1905,9 +2077,9 @@ export declare const CORNToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
 export declare const CROToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -2077,9 +2249,9 @@ export declare const CROToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
 export declare const GNOToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -2249,9 +2421,9 @@ export declare const GNOToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
 export declare const HOODToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -2421,9 +2593,9 @@ export declare const HOODToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
 export declare const HYPEREVMToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -2593,9 +2765,9 @@ export declare const HYPEREVMToolbox: ({ provider, ...toolboxParams }: EVMToolbo
 export declare const LINEAToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -2765,9 +2937,9 @@ export declare const LINEAToolbox: ({ provider, ...toolboxParams }: EVMToolboxPa
 export declare const MATICToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -2937,9 +3109,9 @@ export declare const MATICToolbox: ({ provider, ...toolboxParams }: EVMToolboxPa
 export declare const MEGAETHToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -3109,9 +3281,9 @@ export declare const MEGAETHToolbox: ({ provider, ...toolboxParams }: EVMToolbox
 export declare const MONADToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -3281,9 +3453,9 @@ export declare const MONADToolbox: ({ provider, ...toolboxParams }: EVMToolboxPa
 export declare const PLASMAToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -3453,9 +3625,9 @@ export declare const PLASMAToolbox: ({ provider, ...toolboxParams }: EVMToolboxP
 export declare const SONICToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -3632,9 +3804,9 @@ export declare const UNIToolbox: ({ provider, ...toolboxSignerParams }: EVMToolb
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -3803,9 +3975,9 @@ export declare const UNIToolbox: ({ provider, ...toolboxSignerParams }: EVMToolb
 export declare const XLayerToolbox: ({ provider, ...toolboxParams }: EVMToolboxParams) => {
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;

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

@@ -12,9 +12,9 @@ export declare function createOPStackToolbox(chain: Chain.Optimism | Chain.Base
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;
@@ -190,9 +190,9 @@ export declare const OPToolbox: ({ provider, ...toolboxSignerParams }: EVMToolbo
     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>);
+    broadcastTransaction: (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<{
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<{
         value: string;
         to: string;
         data: string;

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

@@ -2,7 +2,7 @@ import type { ChainSigner, DerivationPathArray, FeeOption, GenericCreateTransact
 import { Chain } from "@swapkit/helpers";
 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";
+import type { ADIToolbox, ARBToolbox, ARCToolbox, 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 {
     Test = "goerli",
     Main = "homestead"
@@ -101,6 +101,7 @@ export type EVMToolboxAsyncParams = {
 export type EVMToolboxes = {
     [Chain.Adi]: ReturnType<typeof ADIToolbox>;
     [Chain.Arbitrum]: ReturnType<typeof ARBToolbox>;
+    [Chain.Arc]: ReturnType<typeof ARCToolbox>;
     [Chain.Aurora]: ReturnType<typeof AURORAToolbox>;
     [Chain.Avalanche]: ReturnType<typeof AVAXToolbox>;
     [Chain.Base]: ReturnType<typeof BASEToolbox>;

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

@@ -1,4 +1,4 @@
-import type { TronSignedTransaction, TronTransaction } from "../types";
+import type { TronGridResponse, TronSignedTransaction, TronTransaction } from "../types";
 export declare function fetchAccountFromTronGrid(address: string): Promise<{
     balance: number;
     trc20: import("../types").TronGridTRC20Balance;
@@ -7,7 +7,7 @@ export declare function buildTrxTransaction({ from, to, amount }: {
     from: string;
     to: string;
     amount: number;
-}): Promise<TronTransaction>;
+}): Promise<TronGridResponse<TronTransaction>>;
 export declare function buildContractTransaction({ ownerAddress, contractAddress, functionSelector, parameter, feeLimit, callValue, }: {
     ownerAddress: string;
     contractAddress: string;

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

@@ -24,6 +24,13 @@ export interface TronTransaction {
         contractRet?: string;
     }>;
 }
+/**
+ * TronGrid answers contract validation failures with HTTP 200 and an `Error` field rather than an
+ * error status, so every response body may carry one alongside (or instead of) the expected shape.
+ */
+export type TronGridResponse<T> = T & {
+    Error?: string;
+};
 export type TronTransactionMetadata = {
     data?: string;
     value?: string;