@swapkit/core 5.0.5 → 5.0.7

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @swapkit/core
 
+## 5.0.7
+
+### Patch Changes
+
+- [#382](https://github.com/swapkit/sdk/pull/382) [`2ef09ec`](https://github.com/swapkit/sdk/commit/2ef09ec782e61176e2576554c25cca6d8f2374de) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - Add Arc (`5042`) EVM chain: chain/chainId enums, chain config, EVM toolbox wiring, and native `ARC.USDC` gas-asset handling in `isGasAsset` / `getCommonAssetInfo` / `getAssetType` / `getTokenAddress`. Arc ships with rpcUrls: [], so connectKeystore skips it and toolbox calls fail with helpers_chain_no_public_or_set_rpc_url until SKConfig.setRpcUrl(Chain.Arc, […]) is set (via @swapkit/toolboxes@5.4.0)
+- [#385](https://github.com/swapkit/sdk/pull/385) [`c8e9da7`](https://github.com/swapkit/sdk/commit/c8e9da74d13ad5b8c533d626400feff9364420fa) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - Expose the address form an address string decodes to, instead of discarding it behind a boolean. Address validation already computed the script type; new siblings surface it without changing any existing validator's return type: (via @swapkit/toolboxes@5.4.0)
+- [#374](https://github.com/swapkit/sdk/pull/374) [`54d0f14`](https://github.com/swapkit/sdk/commit/54d0f14ec3d58e66b0036ad6c8dcfd0f823dbd2a) Thanks [@ice-chillios](https://github.com/ice-chillios)! - `getAddressValidator` now handles the Substrate chains. Polkadot (DOT) and Chainflip (FLIP) had no arm in the chain match, so they fell through to the catch-all and every address — including valid ones — was reported as invalid. Consumers of `swapKit.validateAddress`, which is built on this validator, were affected; the server-side `validateChainAddress` already covered these chains. (via @swapkit/toolboxes@5.4.0)
+- [#393](https://github.com/swapkit/sdk/pull/393) [`25570ca`](https://github.com/swapkit/sdk/commit/25570ca23f90b4ed104061b5561c35ab1c47f1c6) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - **One table describes the UTXO script types.** `@swapkit/helpers` now exports `UTXOScriptType` (with `P2SH_P2WPKH` and `P2TR` alongside `P2PKH` and `P2WPKH`), `UTXO_SCRIPT_TYPES` (BIP43 purpose, input and output size in vBytes, witness flag per type), `UTXO_SCRIPT_TYPE_LIST`, and the path helpers `getPurposeFromPath`, `getUTXOScriptTypeForPurpose` and `getUTXOScriptTypeForPath`. Error key `toolbox_utxo_unsupported_script_type` (50315) is reserved for the toolboxes. (via @swapkit/toolboxes@5.4.0)
+- [#391](https://github.com/swapkit/sdk/pull/391) [`cf94a27`](https://github.com/swapkit/sdk/commit/cf94a27a52ac37c78d3a72bbbe7ee3acf14c192e) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - **Eight fixes to the UTXO send path**, reached today by external signers spending from legacy Bitcoin and Litecoin addresses, and by every chain without segwit. (via @swapkit/toolboxes@5.4.0)
+- [#391](https://github.com/swapkit/sdk/pull/391) [`cf94a27`](https://github.com/swapkit/sdk/commit/cf94a27a52ac37c78d3a72bbbe7ee3acf14c192e) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - **Three fixes to `createReplacementTransaction`/`bumpFee`** (Bitcoin, the only chain in `rbfSupportedChains`): (via @swapkit/toolboxes@5.4.0)
+- [#379](https://github.com/swapkit/sdk/pull/379) [`4450ac4`](https://github.com/swapkit/sdk/commit/4450ac4200a565d5ce38a26d31f3836a3713ff75) Thanks [@ice-chillios](https://github.com/ice-chillios)! - `derivationPathToString` now accepts sliced derivation paths through the new `DerivationPathLike` (`readonly (number | undefined)[]`) type, so prefixes no longer need to be cast to `DerivationPathArray`. (via @swapkit/toolboxes@5.4.0)
+- [#362](https://github.com/swapkit/sdk/pull/362) [`cbbfccd`](https://github.com/swapkit/sdk/commit/cbbfccdcbbe3e5ad3ffb531a030e2562c8e3f470) Thanks [@towanTG](https://github.com/towanTG)! - Preserve stored numeric precision across comparisons, arithmetic operands, copies, `set`, and AssetValue conversion instead of converting through display-rounded strings. Compare exact values regardless of declared asset decimals, and cap arithmetic results at 64 decimal places without mis-scaling longer inputs or turning small nonzero divisors into zero. Fix half-up display carries and explicit base-unit rescaling while preserving asset identity and destination decimals. (via @swapkit/toolboxes@5.4.0)
+- [#399](https://github.com/swapkit/sdk/pull/399) [`70749e7`](https://github.com/swapkit/sdk/commit/70749e7899630daabc371a36c498f62b9da1c62f) Thanks [@github-actions](https://github.com/apps/github-actions)! - Update generated token lists. (via @swapkit/toolboxes@5.4.0)
+- [#374](https://github.com/swapkit/sdk/pull/374) [`54d0f14`](https://github.com/swapkit/sdk/commit/54d0f14ec3d58e66b0036ad6c8dcfd0f823dbd2a) Thanks [@ice-chillios](https://github.com/ice-chillios)! - `ChainflipBroker.fundStateChainAccount` accepts a hex state chain account explicitly instead of relying on the substrate address validator, which no longer treats hex as an address. Hex accounts must now be a full 32-byte `AccountId32`; shorter hex values used to pass validation and then fail in the gateway call. (via @swapkit/plugins@5.0.7)
+
+## 5.0.6
+
+### Patch Changes
+
+- [#371](https://github.com/swapkit/sdk/pull/371) [`6236419`](https://github.com/swapkit/sdk/commit/623641928563f9e0141c47395a2e1febbd182093) Thanks [@ice-chillios](https://github.com/ice-chillios)! - EVM nonce derivation now reads the "pending" transaction count and serialises allocation per chainId:address behind an expiring monotonic floor, so concurrent sends from one address no longer reuse a mined-only count and silently replace each other in the mempool. Allocations are released when a send provably never reached the wire (gas or fee estimation failure, a rejected send, a signer that cannot sign), so a failed attempt no longer strands a nonce gap; transport-ambiguous failures keep the nonce reserved until the floor expires, and a floor never expires while one of its nonces is held by an in-flight send (a signature awaiting hardware or wallet confirmation cannot have its nonce re-issued). sendTransaction and state-changing contract calls both resolve through the signer's own provider when it carries one — approve + send from a single toolbox share one floor, and the transport-failure fallback broadcast and its hash lookup go through that same provider. Caller-supplied nonces are honoured on the ERC-20 transfer and approval builder paths. The native sweep builder no longer pins a nonce into the built transaction — the OP-stack L1 fee serialisation performs its own plain "pending" read for byte-length only (build-only APIs consume no allocation) — so both `transfer` and a two-step `createTransaction`/`sendTransaction` sweep allocate through the floor on the send path. The toolbox `broadcastTransaction` no longer crashes when invoked (previously an unbound method reference). (via @swapkit/toolboxes@5.3.0)
+- [#380](https://github.com/swapkit/sdk/pull/380) [`9e8158f`](https://github.com/swapkit/sdk/commit/9e8158f012909b540652f0047f719482628724e1) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - TRON transaction failures now carry a diagnostic payload instead of a bare error key. (via @swapkit/toolboxes@5.3.0)
+- [#381](https://github.com/swapkit/sdk/pull/381) [`3b750ec`](https://github.com/swapkit/sdk/commit/3b750ec492b40b028f50c1adcf2347c647ad3f2f) Thanks [@ochhii1337](https://github.com/ochhii1337)! - TON's native coin is now `GRAM`, so the gas asset is `TON.GRAM` instead of `TON.TON`. (via @swapkit/toolboxes@5.3.0)
+- Update generated token lists. (via @swapkit/toolboxes@5.3.0)
+
 ## 5.0.5
 
 ### Patch Changes

package/dist/index.js

@@ -1 +1 @@
-var f=((Q)=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(Q,{get:(X,F)=>(typeof require<"u"?require:X)[F]}):Q)(function(Q){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+Q+'" is not supported')});import{ApproveMode as R,AssetValue as _,Chain as U,CosmosChains as l,EVMChains as S,ProviderName as x,SKConfig as t,SwapKitError as Y,UTXOChains as a}from"@swapkit/helpers";import{parseTransactionValue as e}from"@swapkit/helpers/api";export*from"@swapkit/helpers";var jj=[x.FLASHNET,x.MAYAN];function qj({pluginName:Q,providers:X,useDirectSigning:F}){return X.some((B)=>jj.includes(B))||F?"swapkit":Q||X[0]}function zj(Q){let X="approvalTx"in Q?Q.approvalTx:void 0;return X!==void 0&&"txType"in X&&X.txType==="STELLAR"?_.from({asset:Q.buyAsset}):_.from({asset:Q.sellAsset,value:Q.sellAmount})}function Lj({config:Q,plugins:X,wallets:F}={}){if(Q)t.set(Q);let k={},B=Object.entries(X||{}).reduce((j,[z,q])=>{let G=q({getWallet:J});return j[z]=G,j},{}),E=Object.entries(F||{}).reduce((j,[z,q])=>{let G=q.connectWallet({addChain:v});return j[z]=G,j},{});function y(j){let z=j&&B[j],q=Object.values(B).find((H)=>H.supportedSwapkitProviders?.includes(j)),G=z||q;if(!G)throw new Y("core_plugin_not_found");return G}function v(j){let z=J(j.chain),q=j?.balance||z?.balance||[_.from({chain:j.chain})],G={...z,...j,balance:q};return k[j.chain]=G,G}function T({pluginName:j,route:z,useDirectSigning:q}){return y(qj({pluginName:j,providers:z.providers,useDirectSigning:q}))}function V({assetValue:j,plugin:z,route:q,spenderAddress:G,type:H}){if(H===R.CheckOnly&&"isAssetValueApproved"in z)return z.isAssetValueApproved({assetValue:j,route:q,spenderAddress:G});if(H===R.Approve&&"approveAssetValue"in z)return z.approveAssetValue({assetValue:j,route:q,spenderAddress:G});throw new Y({errorKey:"core_approve_asset_target_invalid",info:{message:`Target ${String(G??q?.providers[0])} cannot be used for approve operation`}})}function b({assetValue:j,type:z="checkOnly",contractAddress:q,route:G}){let H=j??(G?zj(G):void 0);if(!H)throw new Y("core_approve_asset_target_invalid");let L=q??G?.meta.approvalAddress,D=G?T({route:G,useDirectSigning:Boolean(J(H.chain)?.supportsDirectSigning)}):L&&B[L];if(D)return V({assetValue:H,plugin:D,route:G,spenderAddress:L,type:z});let P=H.chain,$=S.includes(P);if($&&H.isGasAsset||!$||H.isSynthetic)return Promise.resolve(z==="checkOnly"?!0:"approved");let Z=J(P),O=z==="checkOnly"?Z.isApproved:Z.approve;if(!O)throw new Y("core_wallet_connection_not_found");if(!(H.address&&Z.address&&typeof L==="string"))throw new Y("core_approve_asset_address_or_from_not_found");return O({amount:H.getBaseValue("bigint"),assetAddress:H.address,from:Z.address,spenderAddress:L})}function J(j){return k[j]}function W(){return{...k}}function A(j){return J(j)?.address||""}function w(j,z){return j instanceof _?b({assetValue:j,contractAddress:z,type:R.Approve}):b({route:j,type:R.Approve})}function m(j,z){return j instanceof _?b({assetValue:j,contractAddress:z,type:R.CheckOnly}):b({route:j,type:R.CheckOnly})}function K(j){J(j)?.disconnect?.(),delete k[j]}function h(){for(let j of Object.keys(k))K(j)}function d(j,z){return z?N(j).then(({balance:q})=>q):J(j)?.balance||[]}async function N(j,z=!0){let q=J(j);if(!q)throw new Y("core_wallet_connection_not_found");let G=await q.getBalance?.(q.address,z);return q.balance=G||[_.from({chain:j})],q}function g({route:j,pluginName:z,...q}){let G=_.from({asset:j.sellAsset}).chain,H=J(G);if(!H)throw new Y("core_wallet_connection_not_found");let L=T({pluginName:z,route:j,useDirectSigning:Boolean(H.supportsDirectSigning&&j.tx)});if("swap"in L)return L.swap({...q,route:j});throw new Y("core_plugin_swap_not_found")}function u({assetValue:j,...z}){let q=j.chain;if([U.Radix].includes(q)||!J(q))throw new Y("core_wallet_connection_not_found");return J(q).transfer({...z,assetValue:j})}function c({chain:j,message:z}){let q=J(j);if(!q)throw new Y("core_wallet_connection_not_found");if("signMessage"in q)return q.signMessage?.(z);throw new Y({errorKey:"core_wallet_sign_message_not_supported",info:{chain:j,wallet:q.walletType}})}function o({chain:j,domain:z,primaryType:q,types:G,value:H}){let L=J(j);if(!L)throw new Y("core_wallet_connection_not_found");if("signTypedData"in L&&typeof L.signTypedData==="function")return L.signTypedData({domain:z,primaryType:q,types:G,value:H});throw new Y({errorKey:"core_wallet_sign_typed_data_not_supported",info:{chain:j,wallet:L.walletType}})}async function p({address:j,chain:z,message:q,signature:G}){if(z!==U.THORChain)throw new Y({errorKey:"core_verify_message_not_supported",info:{chain:z}});let{getCosmosToolbox:H}=await import("@swapkit/toolboxes/cosmos");return H(z).verifySignature({address:j,message:q,signature:G})}async function i({type:j,feeOptionKey:z,params:q}){let{assetValue:G}=q,{chain:H}=G;if(!J(H))throw new Y("core_wallet_connection_not_found");let L=_.from({chain:H}),{match:D}=await import("ts-pattern");return await D(H).returnType().with(...S,($)=>{let{address:I,...Z}=J($),O=D(j).with("transfer",()=>Z.createTransferTx(q)).with("approve",(r)=>{let{contractAddress:M}=q;return Z.createApprovalTx({amount:G.getBaseValue("bigint"),assetAddress:G.address,from:I,spenderAddress:M})}).with("swap",(r)=>{let{route:{providers:[M],tx:s}}=q;if(M&&[x.CHAINFLIP,x.CHAINFLIP_STREAMING].includes(M))return Z.createTransferTx({assetValue:G,recipient:I,sender:I});let C=s;return{...C,value:e(C.value)}}).otherwise(()=>{return});if(!O)return L;return Z.estimateTransactionFee({...O,feeOption:z})}).with(...l,async()=>{let{estimateTransactionFee:$}=await import("@swapkit/toolboxes/cosmos");return $(q)}).with(...a,($)=>{let{address:I,...Z}=J($);return Z.estimateTransactionFee({...q,feeOptionKey:z,recipient:I,sender:I})}).with(U.Tron,U.Ton,U.Polkadot,($)=>{let{address:I,...Z}=J($);return Z.estimateTransactionFee({...q,recipient:I,sender:I})}).with(U.Aptos,U.Cardano,U.Ripple,U.Stellar,U.Sui,($)=>J($).estimateTransactionFee()).otherwise(()=>L)}async function n({address:j,chain:z}){try{let{getAddressValidator:q}=await import("@swapkit/toolboxes");return(await q())({address:j,chain:z})}catch{return!1}}return{...B,...E,approveAssetValue:w,disconnectAll:h,disconnectChain:K,estimateTransactionFee:i,getAddress:A,getAllWallets:W,getBalance:d,getWallet:J,getWalletWithBalance:N,isAssetValueApproved:m,signMessage:c,signTypedData:o,swap:g,transfer:u,validateAddress:n,verifyMessage:p}}export{qj as resolveRoutePluginName,zj as getRouteApprovalAssetValue,Lj as SwapKit};
+var v=((i)=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(i,{get:(c,w)=>(typeof require<"u"?require:c)[w]}):i)(function(i){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+i+'" is not supported')});import{ApproveMode as m,AssetValue as g,Chain as f,CosmosChains as z,EVMChains as k,ProviderName as R,SKConfig as J,SwapKitError as l,UTXOChains as Z}from"@swapkit/helpers";import{parseTransactionValue as ee}from"@swapkit/helpers/api";export*from"@swapkit/helpers";var te=[R.FLASHNET,R.MAYAN];function ne({pluginName:i,providers:c,useDirectSigning:w}){return c.some((T)=>te.includes(T))||w?"swapkit":i||c[0]}function ae(i){let c="approvalTx"in i?i.approvalTx:void 0;return c!==void 0&&"txType"in c&&c.txType==="STELLAR"?g.from({asset:i.buyAsset}):g.from({asset:i.sellAsset,value:i.sellAmount})}function ie({config:i,plugins:c,wallets:w}={}){if(i)J.set(i);let y={},T=Object.entries(c||{}).reduce((e,[n,t])=>{let a=t({getWallet:o});return e[n]=a,e},{}),W=Object.entries(w||{}).reduce((e,[n,t])=>{let a=t.connectWallet({addChain:E});return e[n]=a,e},{});function b(e){let n=e&&T[e],t=Object.values(T).find((s)=>s.supportedSwapkitProviders?.includes(e)),a=n||t;if(!a)throw new l("core_plugin_not_found");return a}function E(e){let n=o(e.chain),t=e?.balance||n?.balance||[g.from({chain:e.chain})],a={...n,...e,balance:t};return y[e.chain]=a,a}function C({pluginName:e,route:n,useDirectSigning:t}){return b(ne({pluginName:e,providers:n.providers,useDirectSigning:t}))}function M({assetValue:e,plugin:n,route:t,spenderAddress:a,type:s}){if(s===m.CheckOnly&&"isAssetValueApproved"in n)return n.isAssetValueApproved({assetValue:e,route:t,spenderAddress:a});if(s===m.Approve&&"approveAssetValue"in n)return n.approveAssetValue({assetValue:e,route:t,spenderAddress:a});throw new l({errorKey:"core_approve_asset_target_invalid",info:{message:`Target ${String(a??t?.providers[0])} cannot be used for approve operation`}})}function A({assetValue:e,type:n="checkOnly",contractAddress:t,route:a}){let s=e??(a?ae(a):void 0);if(!s)throw new l("core_approve_asset_target_invalid");let r=t??a?.meta.approvalAddress,h=a?C({route:a,useDirectSigning:Boolean(o(s.chain)?.supportsDirectSigning)}):r&&T[r];if(h)return M({assetValue:s,plugin:h,route:a,spenderAddress:r,type:n});let V=s.chain,u=k.includes(V);if(u&&s.isGasAsset||!u||s.isSynthetic)return Promise.resolve(n==="checkOnly"?!0:"approved");let p=o(V),_=n==="checkOnly"?p.isApproved:p.approve;if(!_)throw new l("core_wallet_connection_not_found");if(!(s.address&&p.address&&typeof r==="string"))throw new l("core_approve_asset_address_or_from_not_found");return _({amount:s.getBaseValue("bigint"),assetAddress:s.address,from:p.address,spenderAddress:r})}function o(e){return y[e]}function O(){return{...y}}function F(e){return o(e)?.address||""}function K(e,n){return e instanceof g?A({assetValue:e,contractAddress:n,type:m.Approve}):A({route:e,type:m.Approve})}function D(e,n){return e instanceof g?A({assetValue:e,contractAddress:n,type:m.CheckOnly}):A({route:e,type:m.CheckOnly})}function S(e){o(e)?.disconnect?.(),delete y[e]}function B(){for(let e of Object.keys(y))S(e)}function I(e,n){return n?x(e).then(({balance:t})=>t):o(e)?.balance||[]}async function x(e,n=!0){let t=o(e);if(!t)throw new l("core_wallet_connection_not_found");let a=await t.getBalance?.(t.address,n);return t.balance=a||[g.from({chain:e})],t}function G({route:e,pluginName:n,...t}){let a=g.from({asset:e.sellAsset}).chain,s=o(a);if(!s)throw new l("core_wallet_connection_not_found");let r=C({pluginName:n,route:e,useDirectSigning:Boolean(s.supportsDirectSigning&&e.tx)});if("swap"in r)return r.swap({...t,route:e});throw new l("core_plugin_swap_not_found")}function L({assetValue:e,...n}){let t=e.chain;if([f.Radix].includes(t)||!o(t))throw new l("core_wallet_connection_not_found");return o(t).transfer({...n,assetValue:e})}function j({chain:e,message:n}){let t=o(e);if(!t)throw new l("core_wallet_connection_not_found");if("signMessage"in t)return t.signMessage?.(n);throw new l({errorKey:"core_wallet_sign_message_not_supported",info:{chain:e,wallet:t.walletType}})}function H({chain:e,domain:n,primaryType:t,types:a,value:s}){let r=o(e);if(!r)throw new l("core_wallet_connection_not_found");if("signTypedData"in r&&typeof r.signTypedData==="function")return r.signTypedData({domain:n,primaryType:t,types:a,value:s});throw new l({errorKey:"core_wallet_sign_typed_data_not_supported",info:{chain:e,wallet:r.walletType}})}async function Q({address:e,chain:n,message:t,signature:a}){if(n!==f.THORChain)throw new l({errorKey:"core_verify_message_not_supported",info:{chain:n}});let{getCosmosToolbox:s}=await import("@swapkit/toolboxes/cosmos");return s(n).verifySignature({address:e,message:t,signature:a})}async function U({type:e,feeOptionKey:n,params:t}){let{assetValue:a}=t,{chain:s}=a;if(!o(s))throw new l("core_wallet_connection_not_found");let r=g.from({chain:s}),{match:h}=await import("ts-pattern");return await h(s).returnType().with(...k,(u)=>{let{address:d,...p}=o(u),_=h(e).with("transfer",()=>p.createTransferTx(t)).with("approve",(Y)=>{let{contractAddress:P}=t;return p.createApprovalTx({amount:a.getBaseValue("bigint"),assetAddress:a.address,from:d,spenderAddress:P})}).with("swap",(Y)=>{let{route:{providers:[P],tx:q}}=t;if(P&&[R.CHAINFLIP,R.CHAINFLIP_STREAMING].includes(P))return p.createTransferTx({assetValue:a,recipient:d,sender:d});let N=q;return{...N,value:ee(N.value)}}).otherwise(()=>{return});if(!_)return r;return p.estimateTransactionFee({..._,feeOption:n})}).with(...z,async()=>{let{estimateTransactionFee:u}=await import("@swapkit/toolboxes/cosmos");return u(t)}).with(...Z,(u)=>{let{address:d,...p}=o(u);return p.estimateTransactionFee({...t,feeOptionKey:n,recipient:d,sender:d})}).with(f.Tron,f.Ton,f.Polkadot,(u)=>{let{address:d,...p}=o(u);return p.estimateTransactionFee({...t,recipient:d,sender:d})}).with(f.Aptos,f.Cardano,f.Ripple,f.Stellar,f.Sui,(u)=>o(u).estimateTransactionFee()).otherwise(()=>r)}async function X({address:e,chain:n}){try{let{getAddressValidator:t}=await import("@swapkit/toolboxes");return(await t())({address:e,chain:n})}catch{return!1}}return{...T,...W,approveAssetValue:K,disconnectAll:B,disconnectChain:S,estimateTransactionFee:U,getAddress:F,getAllWallets:O,getBalance:I,getWallet:o,getWalletWithBalance:x,isAssetValueApproved:D,signMessage:j,signTypedData:H,swap:G,transfer:L,validateAddress:X,verifyMessage:Q}}export{ie as SwapKit,ae as getRouteApprovalAssetValue,ne as resolveRoutePluginName};

package/dist/types/index.d.ts

@@ -49,9 +49,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         ADI: ChainWallet<Chain.Adi> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -275,9 +275,181 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         ARB: ChainWallet<Chain.Arbitrum> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").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("@swapkit/toolboxes/evm").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("@swapkit/toolboxes/evm").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("@swapkit/toolboxes/evm").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("@swapkit/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@swapkit/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@swapkit/toolboxes/evm").EVMTransferParams & {
+                assetValue: import("@swapkit/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@swapkit/toolboxes/evm").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("@swapkit/toolboxes/evm").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("@swapkit/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, sweep, ...tx }: import("@swapkit/toolboxes/evm").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("@swapkit/toolboxes/evm").SignTypedDataParams) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("@swapkit/toolboxes/evm").EVMTransferParams) => Promise<string>;
+            validateAddress: typeof import("@swapkit/toolboxes/evm").validateEVMAddress;
+        };
+        ARC: ChainWallet<Chain.Arc> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: (signedTx: string) => Promise<import("ethers").TransactionResponse>;
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -447,9 +619,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         AURORA: ChainWallet<Chain.Aurora> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -619,9 +791,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         AVAX: ChainWallet<Chain.Avalanche> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -798,9 +970,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             getL1GasPrice: () => Promise<bigint | undefined>;
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -969,9 +1141,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         BERA: ChainWallet<Chain.Berachain> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -1141,9 +1313,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         BSC: ChainWallet<Chain.BinanceSmartChain> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -1373,6 +1545,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             getAddressFromKeys: (keys: {
                 publicKey: Uint8Array;
             }) => string;
+            getAddressType: (address: string) => "pkh" | "sh" | "sprout" | "sapling" | "unified" | "wpkh" | "wsh" | "tr" | null;
             getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
             getExtendedPublicKey: () => string | undefined;
             getExtendedPublicKeyInfo: ({ accountIndex }?: {
@@ -1437,7 +1610,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
                 recipient: string;
                 assetValue: AssetValue;
                 memo?: string;
-                feeRate?: number;
+                feeRate? /**
+                 * @Public
+                 */: number;
                 feeOptionKey?: FeeOption;
                 changeAddress?: string;
                 sweep?: boolean;
@@ -1534,6 +1709,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
                 feeRate?: number;
                 fetchTxHex?: boolean;
             }) => Promise<import("@swapkit/helpers").AssetValue>;
+            getAddressType: (address: string) => "pkh" | "sh" | "sprout" | "sapling" | "unified" | "wpkh" | "wsh" | "tr" | null;
             getExtendedPublicKey: () => string | undefined;
             getExtendedPublicKeyInfo: ({ accountIndex }?: {
                 accountIndex?: number;
@@ -1596,9 +1772,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         BOTANIX: ChainWallet<Chain.Botanix> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -1803,9 +1979,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         CORE: ChainWallet<Chain.Core> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -1975,9 +2151,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         CORN: ChainWallet<Chain.Corn> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -2179,9 +2355,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         CRO: ChainWallet<Chain.Cronos> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -2411,6 +2587,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             getAddressFromKeys: (keys: {
                 publicKey: Uint8Array;
             }) => string;
+            getAddressType: (address: string) => "pkh" | "sh" | "sprout" | "sapling" | "unified" | "wpkh" | "wsh" | "tr" | null;
             getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
             getExtendedPublicKey: () => string | undefined;
             getExtendedPublicKeyInfo: ({ accountIndex }?: {
@@ -2475,7 +2652,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
                 recipient: string;
                 assetValue: AssetValue;
                 memo?: string;
-                feeRate?: number;
+                feeRate? /**
+                 * @Public
+                 */: number;
                 feeOptionKey?: FeeOption;
                 changeAddress?: string;
                 sweep?: boolean;
@@ -2545,6 +2724,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             getAddressFromKeys: (keys: {
                 publicKey: Uint8Array;
             }) => string;
+            getAddressType: (address: string) => "pkh" | "sh" | "sprout" | "sapling" | "unified" | "wpkh" | "wsh" | "tr" | null;
             getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
             getExtendedPublicKey: () => string | undefined;
             getExtendedPublicKeyInfo: ({ accountIndex }?: {
@@ -2609,7 +2789,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
                 recipient: string;
                 assetValue: AssetValue;
                 memo?: string;
-                feeRate?: number;
+                feeRate? /**
+                 * @Public
+                 */: number;
                 feeOptionKey?: FeeOption;
                 changeAddress?: string;
                 sweep?: boolean;
@@ -2623,9 +2805,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             }[], multicallAddress?: string, funcName?: string, feeOptionKey?: FeeOption) => Promise<string>;
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -2795,9 +2977,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         GNO: ChainWallet<Chain.Gnosis> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -2999,9 +3181,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         HYPEREVM: ChainWallet<Chain.Hyperevm> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -3311,6 +3493,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             getAddressFromKeys: (keys: {
                 publicKey: Uint8Array;
             }) => string;
+            getAddressType: (address: string) => "pkh" | "sh" | "sprout" | "sapling" | "unified" | "wpkh" | "wsh" | "tr" | null;
             getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
             getExtendedPublicKey: () => string | undefined;
             getExtendedPublicKeyInfo: ({ accountIndex }?: {
@@ -3375,7 +3558,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
                 recipient: string;
                 assetValue: AssetValue;
                 memo?: string;
-                feeRate?: number;
+                feeRate? /**
+                 * @Public
+                 */: number;
                 feeOptionKey?: FeeOption;
                 changeAddress?: string;
                 sweep?: boolean;
@@ -3385,9 +3570,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         LINEA: ChainWallet<Chain.Linea> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -3558,9 +3743,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         MEGAETH: ChainWallet<Chain.MegaETH> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -3730,9 +3915,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         MONAD: ChainWallet<Chain.Monad> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -3982,9 +4167,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             getL1GasPrice: () => Promise<bigint | undefined>;
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -4153,9 +4338,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         XPL: ChainWallet<Chain.Plasma> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -4347,9 +4532,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         POL: ChainWallet<Chain.Polygon> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -4564,9 +4749,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         HOOD: ChainWallet<Chain.Robinhood> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -4758,9 +4943,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         SONIC: ChainWallet<Chain.Sonic> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -5041,9 +5226,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             getL1GasPrice: () => Promise<bigint | undefined>;
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -5212,9 +5397,9 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
         XLAYER: ChainWallet<Chain.XLayer> & {
             approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
             approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").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_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
-            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<{
                 value: string;
                 to: string;
                 data: string;
@@ -5441,6 +5626,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             getAddressFromKeys: (keys: {
                 publicKey: Uint8Array;
             }) => string;
+            getAddressType: (address: string) => "pkh" | "sh" | "sprout" | "sapling" | "unified" | "wpkh" | "wsh" | "tr" | null;
             getBalance: (address: string, scamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
             getExtendedPublicKey: () => string | undefined;
             getExtendedPublicKeyInfo: ({ accountIndex }?: {

package/package.json

@@ -1,10 +1,10 @@
 {
   "author": "swapkit-dev",
   "dependencies": {
-    "@swapkit/helpers": "5.2.1",
-    "@swapkit/plugins": "5.0.5",
-    "@swapkit/toolboxes": "5.2.1",
-    "@swapkit/wallet-core": "5.0.5"
+    "@swapkit/helpers": "5.4.0",
+    "@swapkit/plugins": "5.0.7",
+    "@swapkit/toolboxes": "5.4.0",
+    "@swapkit/wallet-core": "5.0.7"
   },
   "description": "SwapKit - Core",
   "devDependencies": {
@@ -34,5 +34,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "5.0.5"
+  "version": "5.0.7"
 }