@swapkit/core 5.3.0 → 5.4.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @swapkit/core
 
+## 5.4.0
+
+### Minor Changes
+
+- [#460](https://github.com/swapkit/sdk/pull/460) [`9190931`](https://github.com/swapkit/sdk/commit/9190931bb2c1f911543a22cb8ccc91e3913cfe6c) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - Add limit orders. A `SwapKit` instance with the `swapkit` plugin exposes `swapKit.limitOrder`: `tokens`, `quote`, `build`, `sign`, `submit`, `execute`, `list`, `get`, `allowedProviders` and `canSign`, plus `cancel.build`, `cancel.sign`, `cancel.submit` and `cancel.execute`. `execute({ build })` signs a built order with the connected wallet and submits it in one step; `cancel.execute(orderId)` does the same for a cancellation.
+- [#460](https://github.com/swapkit/sdk/pull/460) [`9190931`](https://github.com/swapkit/sdk/commit/9190931bb2c1f911543a22cb8ccc91e3913cfe6c) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - `SwapKitApi` now covers the full limit-order API: `getLimitOrderTokens`, `getLimitOrderQuote`, `buildLimitOrder`, `submitLimitOrder`, `getLimitOrders`, `getLimitOrder`, `buildLimitOrderCancel` and `submitLimitOrderCancel`, with typed responses and `LimitOrderStatus` and `LimitOrderTxType` constants. `getLimitOrderQuote` accepts an optional `providers` list to restrict the quote to those providers. Each call can be overridden through `SKConfig.endpoints`. (via @swapkit/helpers@6.4.0)
+- [#467](https://github.com/swapkit/sdk/pull/467) [`6ddbd12`](https://github.com/swapkit/sdk/commit/6ddbd12b87af88d304aa575518970214ca4516e9) Thanks [@ice-chillios](https://github.com/ice-chillios)! - `getTokenAddress` and `getChecksumAddressFromAsset` now use `isGasAsset`, so `MONAD.MON`, `XLAYER.OKB` and `GNO.xDAI` resolve to the native asset address instead of returning `null` or throwing. Identifiers that repeat the chain name on a chain whose gas asset has another ticker, such as `ARB.ARB` or `BSC.BSC`, no longer resolve to the native asset address. `ContractAddress[Chain.Optimism]` is now the zero address, like every EVM chain except Polygon, so `OP.ETH` resolves to the zero address instead of the OP token contract (`0x4200000000000000000000000000000000000042`). `OP.OP` without an address still resolves to the OP token contract. The Botanix toolbox now targets the Botanix network instead of Sonic. (via @swapkit/helpers@6.4.0)
+- [#474](https://github.com/swapkit/sdk/pull/474) [`f107064`](https://github.com/swapkit/sdk/commit/f10706478e42440912a009b011b92b4e345104f8) Thanks [@ice-chillios](https://github.com/ice-chillios)! - The TON toolbox spaces out and retries its requests to the public Toncenter endpoint, which allows about one request per second without an API key, so TON jetton sales such as TON.USDT are much less likely to fail there. Requests to the chain's default endpoints start at least 1.1 seconds apart, through a queue shared by every toolbox in the process. Waits therefore grow with concurrent TON activity; for servers and other high-volume use, configure a custom TON RPC or a Toncenter API key, which is not spaced out. The endpoint health check is not queued. A request rejected with 429 or a gateway error (502 and above) is sent again after 1, 2 and 4 seconds. A node's 500 answer, such as a rejected message, a timeout and a network failure fail at once. A jetton lookup that the RPC does not answer is reported as `helpers_chain_rpc_connection_failed` instead of `core_swap_contract_not_found`. A toolbox looks up each jetton wallet address only once per jetton and owner. (via @swapkit/helpers@6.4.0)
+- [#464](https://github.com/swapkit/sdk/pull/464) [`c20cc10`](https://github.com/swapkit/sdk/commit/c20cc10b4534c7948dfe4b57f29e07f1b183f1ca) Thanks [@github-actions](https://github.com/apps/github-actions)! - Update generated token lists. (via @swapkit/helpers@6.4.0)
+- [#460](https://github.com/swapkit/sdk/pull/460) [`9190931`](https://github.com/swapkit/sdk/commit/9190931bb2c1f911543a22cb8ccc91e3913cfe6c) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - The keystore can now sign Bitcoin messages (BIP-137) and declares the `btcMessage` capability for Bitcoin, so flows that need a Bitcoin signed message, like cancelling a Harbor Bitcoin limit order, work with it. (via @swapkit/toolboxes@6.5.0)
+- [#460](https://github.com/swapkit/sdk/pull/460) [`9190931`](https://github.com/swapkit/sdk/commit/9190931bb2c1f911543a22cb8ccc91e3913cfe6c) Thanks [@hippocampusSK](https://github.com/hippocampusSK)! - EVM transactions that carry only a legacy `gasPrice` are now sent as legacy transactions instead of failing on chains that support EIP-1559. (via @swapkit/toolboxes@6.5.0)
+- [#468](https://github.com/swapkit/sdk/pull/468) [`8062907`](https://github.com/swapkit/sdk/commit/8062907e7f2dd5a7c12f436b9ee3a2b5fad66e15) Thanks [@ice-chillios](https://github.com/ice-chillios)! - The TON toolbox no longer falls back to Orbs TON Access when every configured TON RPC fails. That service no longer returns any nodes, so the fallback itself failed with an unclear error. Now the toolbox throws `helpers_chain_rpc_connection_failed`, and jetton transfers and sweeps report that error instead of `core_swap_contract_not_found`. Set a working endpoint with `SKConfig.setRpcUrl(Chain.Ton, [...])` or pass `provider` to the toolbox. The `@orbs-network/ton-access` dependency is removed. (via @swapkit/toolboxes@6.5.0)
+- [#465](https://github.com/swapkit/sdk/pull/465) [`d03591d`](https://github.com/swapkit/sdk/commit/d03591dd257fb2735d1ce1eb72540e11082a084e) Thanks [@towanTG](https://github.com/towanTG)! - Zcash transactions keep working through the NU7 network upgrade (mainnet block 3,543,405, around 5 November 2026), which rejects version 4 transactions. From the activation block on, the Zcash toolbox builds version 5 transactions with the NU7 consensus branch id `0x77190ad9`; before it, nothing changes. If the block height can't be fetched, building a Zcash transaction now fails with `toolbox_utxo_api_error` instead of guessing the format, because a guess on the wrong side of an upgrade produces a transaction the network rejects. `@swapkit/utxo-signer` can now build, sign, parse and compute the txid of transparent version 5 transactions, including version 5 PSBTs and PCZTs, and exports `getZcashTransactionFormat` and `ZCASH_NU7_ACTIVATION_HEIGHT`. Parsing a raw Zcash transaction now keeps input txids in the right byte order, so re-serializing it no longer changes them. (via @swapkit/toolboxes@6.5.0)
+
 ## 5.3.0
 
 ### Minor Changes

package/dist/index.js

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

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 import { AssetValue, Chain, type ChainWallet, type ConditionalAssetValueReturn, type FeeOption, type GenericTransferParams, ProviderName as PluginNameEnum, type SKConfigState, type SwapParams } from "@swapkit/helpers";
-import { type QuoteResponseRoute, type SwapRouteV2Response } from "@swapkit/helpers/api";
-import type { createPlugin } from "@swapkit/plugins";
+import { type LimitOrderQuoteRequest, type QuoteResponseRoute, type SwapRouteV2Response } from "@swapkit/helpers/api";
+import type { createPlugin, SKPlugins } from "@swapkit/plugins";
 import type { FullWallet } from "@swapkit/toolboxes";
 import type { EVMCreateTransactionParams, EVMTransferParams, TypedDataField } from "@swapkit/toolboxes/evm";
 import type { createWallet } from "@swapkit/wallet-core";
@@ -10,6 +10,8 @@ export type SwapKitParams<P, W> = {
     wallets?: W;
 };
 type SwapRoute = QuoteResponseRoute | SwapRouteV2Response;
+type LimitOrderPlugin = ReturnType<SKPlugins["swapkit"]>;
+type LimitOrderSignParams = Parameters<LimitOrderPlugin["limitOrderSign"]>[0];
 export declare function resolveRoutePluginName({ pluginName, providers, useDirectSigning, }: {
     pluginName?: string;
     providers: readonly PluginNameEnum[];
@@ -1598,6 +1600,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             } | undefined;
             scriptType: import("@swapkit/helpers").UTXOScriptType;
             signAndBroadcastTransaction: (tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>) => Promise<string>;
+            signMessage: ((message: string) => Promise<string>) | undefined;
             signTransaction: (tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>) => import("@swapkit/utxo-signer").Transaction | Promise<import("@swapkit/utxo-signer").Transaction>;
             signTransactionWithMultipleKeys: ({ tx, inputDerivations, }: {
                 tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>;
@@ -1754,6 +1757,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
                 index: number;
             } | undefined;
             scriptType: import("@swapkit/helpers").UTXOScriptType;
+            signMessage: ((message: string) => Promise<string>) | undefined;
             signTransactionWithMultipleKeys: ({ tx, inputDerivations, }: {
                 tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>;
                 inputDerivations: import("@swapkit/toolboxes/utxo/types").InputDerivation[];
@@ -2640,6 +2644,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             } | undefined;
             scriptType: import("@swapkit/helpers").UTXOScriptType;
             signAndBroadcastTransaction: (tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>) => Promise<string>;
+            signMessage: ((message: string) => Promise<string>) | undefined;
             signTransaction: (tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>) => import("@swapkit/utxo-signer").Transaction | Promise<import("@swapkit/utxo-signer").Transaction>;
             signTransactionWithMultipleKeys: ({ tx, inputDerivations, }: {
                 tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>;
@@ -2776,6 +2781,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             } | undefined;
             scriptType: import("@swapkit/helpers").UTXOScriptType;
             signAndBroadcastTransaction: (tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>) => Promise<string>;
+            signMessage: ((message: string) => Promise<string>) | undefined;
             signTransaction: (tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>) => import("@swapkit/utxo-signer").Transaction | Promise<import("@swapkit/utxo-signer").Transaction>;
             signTransactionWithMultipleKeys: ({ tx, inputDerivations, }: {
                 tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>;
@@ -3544,6 +3550,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
             } | undefined;
             scriptType: import("@swapkit/helpers").UTXOScriptType;
             signAndBroadcastTransaction: (tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>) => Promise<string>;
+            signMessage: ((message: string) => Promise<string>) | undefined;
             signTransaction: (tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>) => import("@swapkit/utxo-signer").Transaction | Promise<import("@swapkit/utxo-signer").Transaction>;
             signTransactionWithMultipleKeys: ({ tx, inputDerivations, }: {
                 tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>;
@@ -5670,6 +5677,7 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
                 index: number;
             } | undefined;
             scriptType: import("@swapkit/helpers").UTXOScriptType;
+            signMessage: ((message: string) => Promise<string>) | undefined;
             signTransactionWithMultipleKeys: ({ tx, inputDerivations, }: {
                 tx: InstanceType<typeof import("@swapkit/utxo-signer").Transaction>;
                 inputDerivations: import("@swapkit/toolboxes/utxo/types").InputDerivation[];
@@ -5690,6 +5698,304 @@ export declare function SwapKit<Plugins extends ReturnType<typeof createPlugin>,
     getWallet: <T_1 extends Chain>(chain: T_1) => FullWallet[T_1];
     getWalletWithBalance: <T_1 extends Chain>(chain: T_1, scamFilter?: boolean) => Promise<FullWallet[T_1]>;
     isAssetValueApproved: (target: AssetValue | SwapRoute, contractAddress?: string | keyof Plugins) => Promise<boolean>;
+    limitOrder: {
+        allowedProviders: ({ sellAsset }: {
+            sellAsset: AssetValue;
+        }) => (PluginNameEnum.ONEINCH | PluginNameEnum.NEAR | PluginNameEnum.HARBOR)[];
+        build: (json: import("@swapkit/helpers").LimitOrderBuildRequest) => Promise<{
+            nextActions: {
+                method: string;
+                url: string;
+                payload?: unknown;
+            }[];
+            orderHash: string;
+            orderId: string;
+            tx: string | Record<string, unknown> | unknown[] | {
+                data: string;
+                to: string;
+                value: string;
+                from?: string | undefined;
+                gas?: string | undefined;
+                gasPrice?: string | undefined;
+                maxFeePerGas?: string | undefined;
+                maxPriorityFeePerGas?: string | undefined;
+                type?: string | undefined;
+            } | null;
+            txMeta: {
+                txType: "evm" | "cardano" | "near" | "psbt" | "ripple" | "solana" | "starknet" | "stellar" | "sui" | "ton" | "tron";
+                chainId?: number | undefined;
+                memo?: string | undefined;
+            } | null;
+            typedData: {
+                domain: {
+                    [x: string]: unknown;
+                    chainId: number;
+                    name: string;
+                    verifyingContract: string;
+                    version: string;
+                };
+                message: Record<string, unknown>;
+                primaryType: string;
+                types: Record<string, {
+                    name: string;
+                    type: string;
+                }[]>;
+            } | null;
+            approvalTx?: {
+                data: string;
+                from: string;
+                to: string;
+                value: string;
+                gasLimit?: string | undefined;
+                gasPrice?: string | undefined;
+            } | undefined;
+            depositAddress?: string | undefined;
+            depositAmount?: string | undefined;
+            depositMemo?: string | undefined;
+            isApproved?: boolean | undefined;
+            warnings?: {
+                code: string;
+                display: string;
+                tooltip?: string | undefined;
+            }[] | undefined;
+        }>;
+        cancel: {
+            build: (json: {
+                orderId: string;
+            }) => Promise<{
+                btcSignaturePreimage: string | null;
+                cancelTx: {
+                    chainId: number;
+                    data: string;
+                    from: string;
+                    to: string;
+                    value: string;
+                } | null;
+                nextActions: {
+                    method: string;
+                    url: string;
+                    payload?: unknown;
+                }[];
+                orderId: string;
+                typedData: {
+                    domain: {
+                        [x: string]: unknown;
+                        name: string;
+                        version: string;
+                    };
+                    message: {
+                        [x: string]: unknown;
+                        action: "cancel_and_withdraw";
+                        chain: string;
+                        expiry: number;
+                        l1Address: string;
+                        nonce: number;
+                        payload: {
+                            [x: string]: unknown;
+                            orderId: string;
+                        };
+                    };
+                    primaryType: "CancelAndWithdraw";
+                    types: {
+                        [x: string]: unknown;
+                        CancelAndWithdraw: {
+                            name: string;
+                            type: string;
+                        }[];
+                        CancelAndWithdrawPayload: {
+                            name: string;
+                            type: string;
+                        }[];
+                        EIP712Domain: {
+                            name: string;
+                            type: string;
+                        }[];
+                    };
+                } | null;
+            }>;
+            canSign: ({ order }: Parameters<LimitOrderPlugin["limitOrderCanCancel"]>[0]) => boolean;
+            execute: (orderId: string) => Promise<{
+                orderId: string;
+                status: (string & {}) | "CANCELLED" | "EXPIRED" | "FAILED" | "FILLED" | "OPEN" | "PARTIAL" | "PENDING" | "SUBMITTED";
+                cancelRequestedAt?: string | undefined;
+                txHash?: string | undefined;
+                withdrawId?: string | undefined;
+            }>;
+            sign: (params: Parameters<LimitOrderPlugin["limitOrderCancelSign"]>[0]) => Promise<{
+                txHash: string;
+                signature?: undefined;
+            } | {
+                signature: string;
+                txHash?: undefined;
+            } | {
+                txHash?: undefined;
+                signature?: undefined;
+            }>;
+            submit: (json: import("@swapkit/helpers").LimitOrderCancelSubmitRequest) => Promise<{
+                orderId: string;
+                status: (string & {}) | "CANCELLED" | "EXPIRED" | "FAILED" | "FILLED" | "OPEN" | "PARTIAL" | "PENDING" | "SUBMITTED";
+                cancelRequestedAt?: string | undefined;
+                txHash?: string | undefined;
+                withdrawId?: string | undefined;
+            }>;
+        };
+        canSign: ({ sellAsset }: {
+            sellAsset: AssetValue;
+        }) => boolean;
+        execute: (params: LimitOrderSignParams) => Promise<{
+            createdAt: string;
+            orderHash: string;
+            orderId: string;
+            status: (string & {}) | "CANCELLED" | "EXPIRED" | "FAILED" | "FILLED" | "OPEN" | "PARTIAL" | "PENDING" | "SUBMITTED";
+        }>;
+        get: (orderId: string) => Promise<{
+            buyAmount: string;
+            buyAsset: string;
+            chainId: import("@swapkit/types").ChainId | (string & {});
+            createdAt: string;
+            expiresAt: string;
+            fees: {
+                amount: string;
+                asset: string;
+                chain: string;
+                protocol: (string & {}) | import("@swapkit/helpers").ProviderName;
+                type: (string & {}) | import("@swapkit/helpers").FeeTypeEnum;
+                amountBps?: number | undefined;
+            }[];
+            filledBuyAmount: string;
+            filledSellAmount: string;
+            limitPrice: string;
+            maker: string;
+            orderHash: string;
+            orderId: string;
+            provider: (string & {}) | import("@swapkit/helpers").ProviderName;
+            receiver: string | null;
+            sellAmount: string;
+            sellAsset: string;
+            status: (string & {}) | "CANCELLED" | "EXPIRED" | "FAILED" | "FILLED" | "OPEN" | "PARTIAL" | "PENDING" | "SUBMITTED";
+            updatedAt: string;
+            cancelRequestedAt?: string | undefined;
+            depositHash?: string | undefined;
+            txHashes?: {
+                chainId: import("@swapkit/types").ChainId | (string & {});
+                txHash: string;
+                type: "fill" | (string & {}) | "cancel" | "deposit" | "withdraw" | "refund";
+                blockNumber?: number | undefined;
+            }[] | undefined;
+            usdValueClose?: string | null | undefined;
+            usdValueOpen?: string | null | undefined;
+            withdrawHash?: string | undefined;
+        }>;
+        list: (query?: import("@swapkit/helpers").LimitOrderListQuery) => Promise<{
+            orders: {
+                buyAmount: string;
+                buyAsset: string;
+                chainId: import("@swapkit/types").ChainId | (string & {});
+                createdAt: string;
+                expiresAt: string;
+                fees: {
+                    amount: string;
+                    asset: string;
+                    chain: string;
+                    protocol: (string & {}) | import("@swapkit/helpers").ProviderName;
+                    type: (string & {}) | import("@swapkit/helpers").FeeTypeEnum;
+                    amountBps?: number | undefined;
+                }[];
+                filledBuyAmount: string;
+                filledSellAmount: string;
+                limitPrice: string;
+                maker: string;
+                orderHash: string;
+                orderId: string;
+                provider: (string & {}) | import("@swapkit/helpers").ProviderName;
+                receiver: string | null;
+                sellAmount: string;
+                sellAsset: string;
+                status: (string & {}) | "CANCELLED" | "EXPIRED" | "FAILED" | "FILLED" | "OPEN" | "PARTIAL" | "PENDING" | "SUBMITTED";
+                updatedAt: string;
+                cancelRequestedAt?: string | undefined;
+                depositHash?: string | undefined;
+                txHashes?: {
+                    chainId: import("@swapkit/types").ChainId | (string & {});
+                    txHash: string;
+                    type: "fill" | (string & {}) | "cancel" | "deposit" | "withdraw" | "refund";
+                    blockNumber?: number | undefined;
+                }[] | undefined;
+                usdValueClose?: string | null | undefined;
+                usdValueOpen?: string | null | undefined;
+                withdrawHash?: string | undefined;
+            }[];
+            nextCursor?: string | undefined;
+        }>;
+        quote: (request: LimitOrderQuoteRequest) => Promise<{
+            quoteId: string;
+            routes: {
+                buyAmount: string;
+                buyAsset: string;
+                effectiveFillPrice: string;
+                integratorFeeBps: number;
+                limitPrice: string;
+                maxExpirationSeconds: number;
+                minExpirationSeconds: number;
+                provider: (string & {}) | import("@swapkit/helpers").ProviderName;
+                routeId: string;
+                sellAmount: string;
+                sellAsset: string;
+                spotPrice: string;
+                spotPriceDeviationBps: number;
+                takerFeeBps: number;
+                fees?: {
+                    amount: string;
+                    asset: string;
+                    chain: string;
+                    protocol: (string & {}) | import("@swapkit/helpers").ProviderName;
+                    type: (string & {}) | import("@swapkit/helpers").FeeTypeEnum;
+                    amountBps?: number | undefined;
+                }[] | undefined;
+                nextActions?: {
+                    method: string;
+                    url: string;
+                    payload?: unknown;
+                }[] | undefined;
+                warnings?: {
+                    code: string;
+                    display: string;
+                    tooltip?: string | undefined;
+                }[] | undefined;
+            }[];
+            error?: string | undefined;
+            providerErrors?: {
+                errorCode?: string | undefined;
+                message?: string | undefined;
+                provider?: (string & {}) | import("@swapkit/helpers").ProviderName | undefined;
+            }[] | undefined;
+        }>;
+        sign: (params: LimitOrderSignParams) => Promise<{
+            signature: string;
+            depositTxHash?: undefined;
+        } | {
+            depositTxHash: string;
+            signature?: undefined;
+        }>;
+        submit: (json: import("@swapkit/helpers").LimitOrderSubmitRequest) => Promise<{
+            createdAt: string;
+            orderHash: string;
+            orderId: string;
+            status: (string & {}) | "CANCELLED" | "EXPIRED" | "FAILED" | "FILLED" | "OPEN" | "PARTIAL" | "PENDING" | "SUBMITTED";
+        }>;
+        tokens: () => Promise<{
+            crossChain: {
+                assets: string[];
+                chainIds: (import("@swapkit/types").ChainId | (string & {}))[];
+                provider: (string & {}) | import("@swapkit/helpers").ProviderName;
+            }[];
+            singleChain: {
+                assets: string[];
+                chainId: import("@swapkit/types").ChainId | (string & {});
+                provider: (string & {}) | import("@swapkit/helpers").ProviderName;
+            }[];
+        }>;
+    };
     signMessage: ({ chain, message }: {
         chain: Chain;
         message: string;

package/package.json

@@ -1,10 +1,10 @@
 {
   "author": "swapkit-dev",
   "dependencies": {
-    "@swapkit/helpers": "6.3.0",
-    "@swapkit/plugins": "5.1.0",
-    "@swapkit/toolboxes": "6.4.1",
-    "@swapkit/wallet-core": "5.1.0"
+    "@swapkit/helpers": "6.4.0",
+    "@swapkit/plugins": "5.2.0",
+    "@swapkit/toolboxes": "6.5.0",
+    "@swapkit/wallet-core": "5.1.1"
   },
   "description": "SwapKit - Core",
   "devDependencies": {
@@ -34,5 +34,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "5.3.0"
+  "version": "5.4.0"
 }