0xtrails 0.16.2 → 0.17.0

package/dist/actions/index.d.ts

@@ -1,23 +1,7 @@
-export { lend, deposit, swap, assertCondition, custom, } from './actionBuilder.js';
-export { SwapType } from './actionBuilder.js';
-export type { SwapProvider } from './actionBuilder.js';
-export { dynamic, self, isDynamicAmount, isSelfAddress, } from './dynamic.js';
-export type { DynamicAmount } from './dynamic.js';
-export type { ActionAmount, ActionItem, ActionDirection, LendActionItem, SwapActionItem, DepositActionItem, CustomActionItem, AssertActionItem, AssertERC20BalanceItem, AssertNativeBalanceItem, AssertNotExpiredItem, AssertERC20AllowanceItem, } from './types.js';
-export type { BuildCallParams, BuildApproveAndCallParams, Erc20Utils, TokenAccessor, TokenInfo, Call, CallWithData, FeePercent, TokenOrAddress, SupportedTokenSymbol, SupportedChainId, ChainName, ChainId, } from './types.js';
-export type { SupportedChainName as ActionsSupportedChainName, ChainIdentifier as ActionsChainIdentifier, } from './types.js';
-export type { EarnMarket, EarnMarketToken, EarnMarketRewardRate, EarnMarketRewardRateComponent, EarnMarketStatistics, EarnMarketMetadata, EarnMarketStatus, EarnMarketArgumentField, EarnMarketArguments, EarnActionArgs, ProviderId, Provider, ProviderType, EarnType, EarnBalance, EarnBalances, EarnBalanceQuery, EarnBalanceError, } from './types/earn.js';
-export { buildCall, buildApproveAndCall, buildErc20Approve, getAmountWithSlippage, erc20Utils, getEarnProviders, getEarnMarkets, getEarnBalances, } from './utils.js';
-export type { GetProvidersParams, GetProvidersResult, GetMarketsParams, GetMarketsResult, GetEarnBalancesParams, GetEarnBalancesResult, } from './utils.js';
-export { resolveActionsToCalls } from './resolveActions.js';
-export type { ResolveActionsToCallsParams } from './resolveActions.js';
-export { encodeDestinationCalls, flattenDestinationCalls, } from './destinationCalls.js';
-export type { DestinationCallsInput, EncodedDestinationCalls, } from './destinationCalls.js';
-export { QuoteError } from '../quoteError.js';
-export type { QuoteErrorCode } from '../quoteError.js';
-export { uniswapV3 } from './custom-integrations/uniswapV3/uniswapV3.js';
-export type { UniswapV3ChainScoped, UniswapV3GetPoolParams, UniswapV3QuoteSwapParams, UniswapV3QuoteSwapResponse, UniswapV3QuoteSwapType, UniswapV3SwapExactInputSingleParams, UniswapV3SwapExactOutputSingleParams, } from './custom-integrations/uniswapV3/types.js';
-export { sushiswapV3 } from './custom-integrations/sushiswapV3/sushiswapV3.js';
-export type { SushiSwapV3ChainScoped, SushiSwapV3GetPoolParams, SushiSwapV3QuoteSwapParams, SushiSwapV3QuoteSwapResponse, SushiSwapV3QuoteSwapType, SushiSwapV3SwapExactInputSingleParams, SushiSwapV3SwapExactOutputSingleParams, } from './custom-integrations/sushiswapV3/types.js';
-export { TRAILS_ROUTER_ADDRESS } from './constants.js';
-//# sourceMappingURL=index.d.ts.map
+"use client";
+
+import { A as SupportedChainId, C as SupportedTokenSymbol, D as TokenOrAddress, E as TokenInfo, O as SwapProvider, S as LendActionItem, T as TokenAccessor, _ as CustomActionItem, a as AssertActionItem, b as FeePercent, c as AssertNativeBalanceItem, d as BuildCallParams, f as Call, g as ChainName, h as ChainIdentifier, j as SupportedChainName, k as SwapType, l as AssertNotExpiredItem, m as ChainId, n as ActionDirection, o as AssertERC20AllowanceItem, p as CallWithData, r as ActionItem, s as AssertERC20BalanceItem, t as ActionAmount, u as BuildApproveAndCallParams, v as DepositActionItem, w as SwapActionItem, y as Erc20Utils } from "../types-BK0WkVnx.js";
+import { A as deposit, C as DynamicAmount, D as self, E as isSelfAddress, M as swap, O as assertCondition, S as resolveActionsToCalls, T as isDynamicAmount, _ as DestinationCallsInput, a as SushiSwapV3QuoteSwapResponse, b as flattenDestinationCalls, c as SushiSwapV3SwapExactOutputSingleParams, d as UniswapV3GetPoolParams, f as UniswapV3QuoteSwapParams, g as UniswapV3SwapExactOutputSingleParams, h as UniswapV3SwapExactInputSingleParams, i as SushiSwapV3QuoteSwapParams, j as lend, k as custom, l as uniswapV3, m as UniswapV3QuoteSwapType, n as SushiSwapV3ChainScoped, o as SushiSwapV3QuoteSwapType, p as UniswapV3QuoteSwapResponse, r as SushiSwapV3GetPoolParams, s as SushiSwapV3SwapExactInputSingleParams, t as sushiswapV3, u as UniswapV3ChainScoped, v as EncodedDestinationCalls, w as dynamic, x as ResolveActionsToCallsParams, y as encodeDestinationCalls } from "../sushiswapV3-D3h41LNZ.js";
+import { A as Provider, C as EarnMarketMetadata, D as EarnMarketStatus, E as EarnMarketStatistics, M as ProviderType, O as EarnMarketToken, S as EarnMarketArguments, T as EarnMarketRewardRateComponent, _ as EarnBalanceError, a as GetProvidersParams, b as EarnMarket, c as buildCall, d as getAmountWithSlippage, f as getEarnBalances, g as EarnBalance, h as EarnActionArgs, i as GetMarketsResult, j as ProviderId, k as EarnType, l as buildErc20Approve, m as getEarnProviders, n as GetEarnBalancesResult, o as GetProvidersResult, p as getEarnMarkets, r as GetMarketsParams, s as buildApproveAndCall, t as GetEarnBalancesParams, u as erc20Utils, v as EarnBalanceQuery, w as EarnMarketRewardRate, x as EarnMarketArgumentField, y as EarnBalances } from "../utils-KPnWBA9x.js";
+import { n as QuoteErrorCode, t as QuoteError } from "../quoteError-CmTH5Qm2.js";
+export { type ActionAmount, type ActionDirection, type ActionItem, type ChainIdentifier as ActionsChainIdentifier, type SupportedChainName as ActionsSupportedChainName, type AssertActionItem, type AssertERC20AllowanceItem, type AssertERC20BalanceItem, type AssertNativeBalanceItem, type AssertNotExpiredItem, type BuildApproveAndCallParams, type BuildCallParams, type Call, type CallWithData, type ChainId, type ChainName, type CustomActionItem, type DepositActionItem, type DestinationCallsInput, type DynamicAmount, type EarnActionArgs, type EarnBalance, type EarnBalanceError, type EarnBalanceQuery, type EarnBalances, type EarnMarket, type EarnMarketArgumentField, type EarnMarketArguments, type EarnMarketMetadata, type EarnMarketRewardRate, type EarnMarketRewardRateComponent, type EarnMarketStatistics, type EarnMarketStatus, type EarnMarketToken, type EarnType, type EncodedDestinationCalls, type Erc20Utils, type FeePercent, type GetEarnBalancesParams, type GetEarnBalancesResult, type GetMarketsParams, type GetMarketsResult, type GetProvidersParams, type GetProvidersResult, type LendActionItem, type Provider, type ProviderId, type ProviderType, QuoteError, type QuoteErrorCode, type ResolveActionsToCallsParams, type SupportedChainId, type SupportedTokenSymbol, type SushiSwapV3ChainScoped, type SushiSwapV3GetPoolParams, type SushiSwapV3QuoteSwapParams, type SushiSwapV3QuoteSwapResponse, type SushiSwapV3QuoteSwapType, type SushiSwapV3SwapExactInputSingleParams, type SushiSwapV3SwapExactOutputSingleParams, type SwapActionItem, type SwapProvider, SwapType, type TokenAccessor, type TokenInfo, type TokenOrAddress, type UniswapV3ChainScoped, type UniswapV3GetPoolParams, type UniswapV3QuoteSwapParams, type UniswapV3QuoteSwapResponse, type UniswapV3QuoteSwapType, type UniswapV3SwapExactInputSingleParams, type UniswapV3SwapExactOutputSingleParams, assertCondition, buildApproveAndCall, buildCall, buildErc20Approve, custom, deposit, dynamic, encodeDestinationCalls, erc20Utils, flattenDestinationCalls, getAmountWithSlippage, getEarnBalances, getEarnMarkets, getEarnProviders, isDynamicAmount, isSelfAddress, lend, resolveActionsToCalls, self, sushiswapV3, swap, uniswapV3 };

package/dist/actions/index.js

@@ -1,37 +1 @@
-import { QuoteError as r } from "../quoteError.js";
-import { dynamic as i, isDynamicAmount as e, isSelfAddress as m, self as s } from "./dynamic.js";
-import { TRAILS_ROUTER_ADDRESS as a } from "./constants.js";
-import { buildApproveAndCall as n, buildCall as f, buildErc20Approve as d, erc20Utils as u, getAmountWithSlippage as A, getEarnBalances as c, getEarnMarkets as E, getEarnProviders as C } from "./utils.js";
-import { uniswapV3 as g } from "./custom-integrations/uniswapV3/uniswapV3.js";
-import { sushiswapV3 as v } from "./custom-integrations/sushiswapV3/sushiswapV3.js";
-import { SwapType as R } from "./resolvers.js";
-import { resolveActionsToCalls as b } from "./resolveActions.js";
-import { encodeDestinationCalls as h, flattenDestinationCalls as U } from "./destinationCalls.js";
-import { assertCondition as _, custom as k, deposit as x, lend as B, swap as I } from "./actionBuilder.js";
-export {
-  r as QuoteError,
-  R as SwapType,
-  a as TRAILS_ROUTER_ADDRESS,
-  _ as assertCondition,
-  n as buildApproveAndCall,
-  f as buildCall,
-  d as buildErc20Approve,
-  k as custom,
-  x as deposit,
-  i as dynamic,
-  h as encodeDestinationCalls,
-  u as erc20Utils,
-  U as flattenDestinationCalls,
-  A as getAmountWithSlippage,
-  c as getEarnBalances,
-  E as getEarnMarkets,
-  C as getEarnProviders,
-  e as isDynamicAmount,
-  m as isSelfAddress,
-  B as lend,
-  b as resolveActionsToCalls,
-  s as self,
-  v as sushiswapV3,
-  I as swap,
-  g as uniswapV3
-};
+import{C as e,S as t,T as n,_ as r,a as i,c as a,d as o,f as s,g as c,h as l,i as u,l as d,m as f,n as p,o as m,p as h,r as g,s as _,t as v,u as y,v as b,w as x,x as S,y as C}from"../actionBuilder-CAS2u5wu.js";export{n as QuoteError,d as SwapType,v as assertCondition,s as buildApproveAndCall,h as buildCall,f as buildErc20Approve,p as custom,g as deposit,S as dynamic,m as encodeDestinationCalls,l as erc20Utils,_ as flattenDestinationCalls,c as getAmountWithSlippage,r as getEarnBalances,b as getEarnMarkets,C as getEarnProviders,t as isDynamicAmount,e as isSelfAddress,u as lend,a as resolveActionsToCalls,x as self,y as sushiswapV3,i as swap,o as uniswapV3};

package/dist/contractConstants-CvJrYK9v.js

@@ -0,0 +1 @@
+const e=`https://nodes.sequence.app`,t=`https://indexer.sequence.app`,n=`https://metadata.sequence.app`,r=`https://trails-api.sequence.app`,i=`10c5ac56159da00924d110c07c3f6e3a`,a=`0.05`,o={trailsApiKey:``,sequenceIndexerUrl:t,sequenceNodeGatewayUrl:e,sequenceMetadataUrl:n,trailsApiUrl:r,walletConnectProjectId:i,slippageTolerance:a,debug:!1,commitHash:void 0};o.commitHash=f();let s=!1;function c(e){s=e}function l(){return s}function u(e){Object.assign(o,e)}function d(e){return e?o[e]:o}function f(){let e=p(`CF_PAGES_COMMIT_SHA`),t=p(`VITE_COMMIT_SHA`);return e&&console.log(`[trails-sdk][config] commit hash from CF_PAGES_COMMIT_SHA: ${e}`),t&&console.log(`[trails-sdk][config] commit hash from VITE_COMMIT_SHA: ${t}`),e||t}function p(e){if(import.meta.env){let t=import.meta.env[`VITE_${e}`];if(t!==void 0&&t!==``)return t;let n=import.meta.env[e];if(n!==void 0&&n!==``)return n}if(typeof process<`u`&&process?.env){let t=process.env[e];if(t!==void 0&&t!==``)return t}}const m=1e3,h=60*m,g=60*h,_=24*g,v=3600,y=()=>Date.now(),b=e=>y()-e,x=e=>Math.floor(e/m),S=(e,t)=>e>0&&b(e)<t,C=e=>Math.min(m*2**e,30*m);function w(e){if(e<60)return`${e}s`;let t=Math.floor(e/v),n=Math.floor(e%v/60),r=e%60;return t===0?r>0?`${n}m${r}s`:`${n}m`:`${t}h${[n>0&&`${n}m`,r>0&&`${r}s`].filter(Boolean).join(``)}`}const T=e=>{if(!e)return{relative:null,full:null};try{let t=new Date(e),n=y()-t.getTime(),r=Math.floor(n/m),i=Math.floor(r/60),a=Math.floor(i/60),o=Math.floor(a/24),s=Math.floor(o/7),c=Math.floor(o/30),l=Math.floor(o/365),u;u=r<60?`just now`:i<60?`${i}m ago`:a<24?`${a}h ago`:o<7?o===1?`1 day ago`:`${o} days ago`:s<4?s===1?`1 week ago`:`${s} weeks ago`:c<12?c===1?`1 month ago`:`${c} months ago`:l===1?`1 year ago`:`${l} years ago`;let d=t.toLocaleDateString(`en-US`,{month:`short`,day:`numeric`,year:`numeric`,hour:`2-digit`,minute:`2-digit`});return{relative:u,full:d}}catch{return{relative:null,full:null}}};function E(e){return`${Math.floor(e/60)}:${(e%60).toString().padStart(2,`0`)}`}function D(e){if(!e)return`Sent just now`;let t=x(b(e));if(t<1)return`Sent just now`;if(t===1)return`Sent 1 second ago`;if(t<60)return`Sent ${t} seconds ago`;let n=Math.floor(t/60);if(n===1)return`Sent 1 minute ago`;if(n<60)return`Sent ${n} minutes ago`;let r=Math.floor(n/60);if(r===1)return`Sent 1 hour ago`;if(r<24)return`Sent ${r} hours ago`;let i=Math.floor(r/24);return i===1?`Sent 1 day ago`:`Sent ${i} days ago`}const O={trailsUtilsAddress:`0x000000004f702C8398e158108937814d074cD74b`,trailsIntentEntrypointAddress:`0x91E9e3Fe369CF005dB2857Ef24955A66d1E692Cf`,trailsRouterAddress:`0xBaE357CBAA04a68cbfD5a560Ab06C4E9A3328A90`,trailsRouterShimAddress:`0xde04013becF982866A04d928A6df25e0D1FAaA71`};export{i as C,r as D,e as E,a as S,n as T,d as _,h as a,c as b,E as c,S as d,y as f,f as g,x as h,v as i,w as l,D as m,_ as n,m as o,C as p,g as r,b as s,O as t,T as u,p as v,t as w,u as x,l as y};

package/dist/defineProperty-BbfpZ9Tg.js

@@ -0,0 +1 @@
+function e(t){"@babel/helpers - typeof";return e=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},e(t)}function t(t,n){if(e(t)!=`object`||!t)return t;var r=t[Symbol.toPrimitive];if(r!==void 0){var i=r.call(t,n||`default`);if(e(i)!=`object`)return i;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(n===`string`?String:Number)(t)}function n(n){var r=t(n,`string`);return e(r)==`symbol`?r:r+``}function r(e,t,r){return(t=n(t))in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}export{r as t};

package/dist/edge-DmNcuJar.d.ts

@@ -0,0 +1,121 @@
+import { t as Token$1 } from "./tokenTypes-D812t5L9.js";
+import { TokenInfo } from "@0xtrails/api";
+import { QueryClient } from "@tanstack/react-query";
+
+//#region src/tokens.d.ts
+/**
+ * Converts ApiTokenInfo (from trails-api) to Token
+ */
+declare function convertApiTokenInfoToToken(tokenInfo: TokenInfo, options?: {
+  balance?: string;
+  priceUsd?: number;
+}): Token$1;
+declare function getSupportedTokens(config: {
+  trailsApiKey: string;
+  trailsApiUrl: string;
+  queryClient?: QueryClient;
+}): Promise<Token$1[]>;
+declare function getTokenInfo(chainId: number, contractAddress: string, config: {
+  trailsApiKey: string;
+  trailsApiUrl: string;
+  sequenceMetadataUrl: string;
+  queryClient?: QueryClient;
+}): Promise<Token$1 | null>;
+declare function getTokenAddress(chainId: number, tokenSymbol: string, config: {
+  trailsApiKey: string;
+  trailsApiUrl: string;
+  queryClient?: QueryClient;
+}): Promise<string>;
+declare function getCommonTokenImageUrl({
+  symbol,
+  contractAddress,
+  chainId
+}: {
+  symbol?: string | null;
+  contractAddress?: string | null;
+  chainId?: number | null;
+}): "" | "https://assets.sequence.info/images/tokens/large/1/0x0000000000000000000000000000000000000000.webp" | "https://assets.sequence.info/images/tokens/large/1/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.webp" | "https://assets.sequence.info/images/tokens/large/137/0x0000000000000000000000000000000000000000.webp" | "https://assets.sequence.info/images/tokens/large/1/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.webp" | "https://assets.sequence.info/images/tokens/large/1/0xdac17f958d2ee523a2206206994597c13d831ec7.webp" | "https://assets.sequence.info/images/tokens/large/1/0x6b175474e89094c44da98b954eedeac495271d0f.webp" | "https://assets.sequence.info/images/tokens/large/1/0x2260fac5e5542a773aa44fbcfedf7c193bc2c599.webp" | "https://assets.sequence.info/images/tokens/large/1/0x0d8775f648430679a709e98d2b0cb6250d2887ef.webp" | "https://assets.sequence.info/images/tokens/large/42161/0x912ce59144191c1204e64559fe8253a0e49e6548.webp" | "https://assets.sequence.info/images/tokens/large/1/0x514910771af9ca656af840dff83e8264ecf986ca.webp" | "https://assets.sequence.info/images/tokens/large/42793/0x0000000000000000000000000000000000000000.webp" | "https://assets.sequence.info/images/tokens/large/56/0x0000000000000000000000000000000000000000.webp" | "https://assets.coingecko.com/coins/images/976/standard/Tezos-logo.png?1696502091" | "https://raw.githubusercontent.com/0xsequence/token-directory/master/index/somnia/logos/somi.png" | "https://assets.coingecko.com/coins/images/34258/large/round_icon_2048_px.png?1719523838" | "https://assets.sequence.info/images/tokens/large/33139/0x0000000000000000000000000000000000000000.webp" | "https://assets.coingecko.com/coins/images/53575/large/anime.jpg?1736748703" | "https://assets.sequence.info/images/tokens/large/43114/0x0000000000000000000000000000000000000000.webp" | "https://assets.coingecko.com/coins/images/4128/standard/solana.png?1718769756" | "https://assets.sequence.info/images/tokens/large/143/0x0000000000000000000000000000000000000000.webp" | "https://assets.coingecko.com/coins/images/53705/standard/usdt0.jpg?1737086183" | "https://assets.coingecko.com/coins/images/39284/standard/Circle_Agora_White_on_Olive_1080px.png?1722961274";
+declare function getSequenceMetadataTokenImageUrl({
+  chainId,
+  contractAddress,
+  fallbackImageUrl,
+  sequenceMetadataUrl
+}: {
+  chainId: number;
+  contractAddress: string;
+  fallbackImageUrl?: string;
+  sequenceMetadataUrl?: string;
+}): string;
+//#endregion
+//#region src/plugins/edgeTypes.d.ts
+/** Registered edge rails. Extend when adding Bitcoin, Tron, etc. */
+declare const EDGE_RAIL: {
+  readonly SOLANA: "solana";
+};
+type EdgeRailId = (typeof EDGE_RAIL)[keyof typeof EDGE_RAIL];
+/** Solana-origin edge wallet + RPC config (Relay `EdgeRail.SOLANA`). */
+type SolanaEdgeOriginConfig = {
+  rail: typeof EDGE_RAIL.SOLANA;
+  rpcUrls: readonly string[];
+  signerPublicKeyBase58: string;
+};
+/** Discriminated union of per-rail origin configs. */
+type EdgeOriginConfig = SolanaEdgeOriginConfig;
+/** Solana-destination edge config (EVM → Solana, etc.). */
+type SolanaEdgeDestinationConfig = {
+  rail: typeof EDGE_RAIL.SOLANA; /** Relay edge chain id — not the SDK UI chain id (101). */
+  chainId: number; /** Recipient in the destination rail's native address format. */
+  recipient: string;
+};
+/** Discriminated union of per-rail destination configs. */
+type EdgeDestinationConfig = SolanaEdgeDestinationConfig;
+/**
+ * @deprecated Use {@link SolanaEdgeOriginConfig} (`rail`-discriminated). Kept for
+ * backward-compatible imports; omits the `rail` discriminator only.
+ */
+type SolanaEdgeWalletConfig = Omit<SolanaEdgeOriginConfig, "rail">;
+declare function isSolanaEdgeOriginConfig(config: EdgeOriginConfig): config is SolanaEdgeOriginConfig;
+declare function isSolanaEdgeDestinationConfig(config: EdgeDestinationConfig): config is SolanaEdgeDestinationConfig;
+declare function createSolanaEdgeOriginConfig(config: Omit<SolanaEdgeOriginConfig, "rail">): SolanaEdgeOriginConfig;
+declare function createSolanaEdgeDestinationConfig(config: Omit<SolanaEdgeDestinationConfig, "rail">): SolanaEdgeDestinationConfig;
+//#endregion
+//#region src/plugins/edge.d.ts
+type EdgeDepositParams = {
+  providerQuote: unknown;
+};
+/** Options when resolving a destination edge recipient from widget / intent input. */
+type BuildEdgeDestinationConfigOptions = {
+  /**
+   * Recipient in the destination rail's native address format. Each plugin
+   * validates format and resolves from props and/or a connected wallet.
+   */
+  recipient?: string | null;
+};
+interface EdgePlugin {
+  /** Which edge rail this plugin implements (Relay `EdgeRail` counterpart). */
+  readonly rail: EdgeRailId;
+  /** Whether this plugin handles the given chain ID as an origin (wallet-state independent). */
+  supportsChain(fromChainId: number): boolean;
+  /** Returns config when wallet is connected and ready; null otherwise. */
+  buildEdgeConfig(fromChainId: number): EdgeOriginConfig | null;
+  executeDeposit(params: EdgeDepositParams): Promise<string[]>;
+  /** Origin tokens supported by this rail. */
+  getOriginTokens(): Token$1[];
+  /** Whether this plugin handles the given chain ID as a destination (wallet-state independent). */
+  supportsDestinationChain?(toChainId: number): boolean;
+  /**
+   * Returns destination edge config when a valid recipient is available
+   * (from `options.recipient` and/or a connected wallet for the rail).
+   */
+  buildEdgeDestinationConfig?(toChainId: number, options?: BuildEdgeDestinationConfigOptions): EdgeDestinationConfig | null;
+  /** Destination tokens supported by this rail. */
+  getDestinationTokens?(): Token$1[];
+}
+declare const EdgePluginContext: import("react").Context<EdgePlugin[]>;
+declare function useEdgePlugins(): EdgePlugin[];
+/** Returns the first registered plugin that supports the given chain as an origin, or null. */
+declare function useEdgePluginForChain(fromChainId: number | null): EdgePlugin | null;
+/** Returns the first registered plugin that supports the given chain as a destination, or null. */
+declare function useEdgePluginForDestinationChain(toChainId: number | null): EdgePlugin | null;
+//#endregion
+export { getTokenAddress as C, getSupportedTokens as S, isSolanaEdgeDestinationConfig as _, useEdgePluginForChain as a, getCommonTokenImageUrl as b, EDGE_RAIL as c, EdgeRailId as d, SolanaEdgeDestinationConfig as f, createSolanaEdgeOriginConfig as g, createSolanaEdgeDestinationConfig as h, EdgePluginContext as i, EdgeDestinationConfig as l, SolanaEdgeWalletConfig as m, EdgeDepositParams as n, useEdgePluginForDestinationChain as o, SolanaEdgeOriginConfig as p, EdgePlugin as r, useEdgePlugins as s, BuildEdgeDestinationConfigOptions as t, EdgeOriginConfig as u, isSolanaEdgeOriginConfig as v, getTokenInfo as w, getSequenceMetadataTokenImageUrl as x, convertApiTokenInfoToToken as y };

package/dist/edge-L_Lk1K6j.js

@@ -0,0 +1 @@
+import{createContext as e,useContext as t,useMemo as n}from"react";const r={SOLANA:`solana`};function i(e){return e.rail===r.SOLANA}function a(e){return e.rail===r.SOLANA}function o(e){return{rail:r.SOLANA,...e}}function s(e){return{rail:r.SOLANA,...e}}const c=e([]);function l(){return t(c)}function u(e){let t=l();return n(()=>e?t.find(t=>t.supportsChain(e))??null:null,[e,t])}function d(e){let t=l();return n(()=>e?t.find(t=>t.supportsDestinationChain?.(e))??null:null,[e,t])}export{r as a,a as c,l as i,i as l,u as n,s as o,d as r,o as s,c as t};

package/dist/hooks/index.d.ts

@@ -1,38 +1,6 @@
-export { useQuote } from '../prepareSend.js';
-export type { UseQuoteReturn, UseQuoteProps, SwapReturn, Quote, QuoteErrorCode, } from '../prepareSend.js';
-export { useIntentReceiptMonitor } from '../intentReceiptMonitor.js';
-export type { IntentReceiptStatus } from '../intentReceiptMonitor.js';
-export { useTrailsSendTransaction } from './useTrailsSendTransaction.js';
-export type { UseTrailsSendTransactionParameters, UseTrailsSendTransactionReturnType, TrailsSendTransactionVariables, } from './useTrailsSendTransaction.js';
-export { useGetIntent } from './useGetIntent.js';
-export type { UseGetIntentParams, UseGetIntentReturn, } from './useGetIntent.js';
-export { useIntentTransactionHistory } from './useIntentTransactionHistory.js';
-export type { UseIntentTransactionHistoryParams, UseIntentTransactionHistoryReturn, } from './useIntentTransactionHistory.js';
-export { useAccountTransactionHistory } from '../transactions.js';
-export type { UseAccountTransactionHistoryParams, UseAccountTransactionHistoryReturn, } from '../transactions.js';
-export { useCommitIntent, useExecuteIntent } from '../mutations.js';
-export { useEarnMarkets } from '../actions/hooks/useEarnMarkets.js';
-export type { UseEarnMarketsParams, UseEarnMarketsReturn, } from '../actions/hooks/useEarnMarkets.js';
-export { useEarnBalances } from '../actions/hooks/useEarnBalances.js';
-export type { UseEarnBalancesParams, UseEarnBalancesReturn, } from '../actions/hooks/useEarnBalances.js';
-export { useEarnProviders } from '../actions/hooks/useEarnProviders.js';
-export type { UseEarnProvidersParams, UseEarnProvidersReturn, } from '../actions/hooks/useEarnProviders.js';
-export { useResolveActions } from '../actions/hooks/useResolveActions.js';
-export type { UseResolveActionsProps, UseResolveActionsReturn, } from '../actions/hooks/useResolveActions.js';
-export { MIN_REFETCH_INTERVAL, useAccountTotalBalanceUsd, useHasSufficientBalanceToken, useHasSufficientBalanceUsd, useTokenBalances, useTokenBalancesForMultipleAccounts, } from '../query/balance.hooks.js';
-export type { NativeTokenBalance, TokenBalance, } from '../query/balance.hooks.js';
-export { useSupportedTokens, useTokenList, useGetTokenImageUrl, useGetSequenceMetadataTokenImageUrl, useTokenAddress, useTokenInfo, } from '../query/token.hooks.js';
-export { useTokenPrice, useTokenPrices } from '../query/price.hooks.js';
-export { useSupportedChains, usePublicClient } from '../query/chains.hooks.js';
-export { useIndexerGatewayClient } from '../indexerClient.js';
-export { useCountryCode, useCountryList } from '../query/geo.hooks.js';
-export { useFiatCurrencyList, useExchangeRate } from '../query/fiat.hooks.js';
-export { useMeldPaymentMethods, useMeldServiceProviders, } from '../query/meld.hooks.js';
-export { useTrailsClient } from '../trailsClient.js';
-export { useOnrampClient } from '../onrampClient.js';
-export { useKeymachineIntentRecovery, useIntentRecover, useIntentRecoverWithAddress, } from '../recover.js';
-export type { UseKeymachineIntentRecoveryParams, UseKeymachineIntentRecoveryReturn, UseIntentRecoverParams, UseIntentRecoverReturn, UseIntentRecoverWithAddressParams, UseIntentRecoverWithAddressReturn, } from '../recover.js';
-export { useOfflineIntentRecovery } from '../offlineRecovery.js';
-export type { UseOfflineIntentRecoveryParams, UseOfflineIntentRecoveryReturn, } from '../offlineRecovery.js';
-export type { Mode } from './useViewManager.js';
-//# sourceMappingURL=index.d.ts.map
+"use client";
+
+import { n as QuoteErrorCode } from "../quoteError-CmTH5Qm2.js";
+import { C as SwapReturn, E as useQuote, T as UseQuoteReturn, b as Quote, dt as UseAccountTransactionHistoryParams, ft as UseAccountTransactionHistoryReturn, ht as useAccountTransactionHistory, t as Mode, w as UseQuoteProps } from "../useViewManager-BeUH_k1s.js";
+import { A as useTokenPrice, B as TokenBalance, C as useFiatCurrencyList, Ct as TrailsSendTransactionVariables, D as usePublicClient, Dt as IntentReceiptStatus, E as useIndexerGatewayClient, Et as useTrailsSendTransaction, F as useTokenAddress, G as useHasSufficientBalanceUsd, H as UseHasSufficientBalanceUsdParams, I as useTokenInfo, K as useTokenBalances, L as useTokenList, M as useGetSequenceMetadataTokenImageUrl, N as useGetTokenImageUrl, Ot as useIntentReceiptMonitor, P as useSupportedTokens, R as MIN_REFETCH_INTERVAL, S as useExchangeRate, St as useGetIntent, T as useCountryList, Tt as UseTrailsSendTransactionReturnType, U as useAccountTotalBalanceUsd, V as UseHasSufficientBalanceTokenParams, W as useHasSufficientBalanceToken, _t as UseIntentTransactionHistoryParams, at as useResolveActions, b as useMeldPaymentMethods, bt as UseGetIntentParams, c as UseIntentRecoverWithAddressParams, ct as useEarnProviders, d as UseKeymachineIntentRecoveryReturn, dt as useEarnBalances, ft as UseEarnMarketsParams, g as useKeymachineIntentRecovery, gt as useExecuteIntent, h as useIntentRecoverWithAddress, ht as useCommitIntent, i as useOfflineIntentRecovery, it as UseResolveActionsReturn, j as useTokenPrices, jt as useTrailsClient, k as useSupportedChains, l as UseIntentRecoverWithAddressReturn, lt as UseEarnBalancesParams, m as useIntentRecover, mt as useEarnMarkets, n as UseOfflineIntentRecoveryReturn, o as UseIntentRecoverParams, ot as UseEarnProvidersParams, pt as UseEarnMarketsReturn, q as useTokenBalancesForMultipleAccounts, rt as UseResolveActionsProps, s as UseIntentRecoverReturn, st as UseEarnProvidersReturn, t as UseOfflineIntentRecoveryParams, u as UseKeymachineIntentRecoveryParams, ut as UseEarnBalancesReturn, v as useOnrampClient, vt as UseIntentTransactionHistoryReturn, w as useCountryCode, wt as UseTrailsSendTransactionParameters, x as useMeldServiceProviders, xt as UseGetIntentReturn, yt as useIntentTransactionHistory, z as NativeTokenBalance } from "../offlineRecovery-BfgccnFf.js";
+export { type IntentReceiptStatus, MIN_REFETCH_INTERVAL, type Mode, type NativeTokenBalance, type Quote, type QuoteErrorCode, type SwapReturn, type TokenBalance, type TrailsSendTransactionVariables, type UseAccountTransactionHistoryParams, type UseAccountTransactionHistoryReturn, type UseEarnBalancesParams, type UseEarnBalancesReturn, type UseEarnMarketsParams, type UseEarnMarketsReturn, type UseEarnProvidersParams, type UseEarnProvidersReturn, type UseGetIntentParams, type UseGetIntentReturn, type UseHasSufficientBalanceTokenParams, type UseHasSufficientBalanceUsdParams, type UseIntentRecoverParams, type UseIntentRecoverReturn, type UseIntentRecoverWithAddressParams, type UseIntentRecoverWithAddressReturn, type UseIntentTransactionHistoryParams, type UseIntentTransactionHistoryReturn, type UseKeymachineIntentRecoveryParams, type UseKeymachineIntentRecoveryReturn, type UseOfflineIntentRecoveryParams, type UseOfflineIntentRecoveryReturn, type UseQuoteProps, type UseQuoteReturn, type UseResolveActionsProps, type UseResolveActionsReturn, type UseTrailsSendTransactionParameters, type UseTrailsSendTransactionReturnType, useAccountTotalBalanceUsd, useAccountTransactionHistory, useCommitIntent, useCountryCode, useCountryList, useEarnBalances, useEarnMarkets, useEarnProviders, useExchangeRate, useExecuteIntent, useFiatCurrencyList, useGetIntent, useGetSequenceMetadataTokenImageUrl, useGetTokenImageUrl, useHasSufficientBalanceToken, useHasSufficientBalanceUsd, useIndexerGatewayClient, useIntentReceiptMonitor, useIntentRecover, useIntentRecoverWithAddress, useIntentTransactionHistory, useKeymachineIntentRecovery, useMeldPaymentMethods, useMeldServiceProviders, useOfflineIntentRecovery, useOnrampClient, usePublicClient, useQuote, useResolveActions, useSupportedChains, useSupportedTokens, useTokenAddress, useTokenBalances, useTokenBalancesForMultipleAccounts, useTokenInfo, useTokenList, useTokenPrice, useTokenPrices, useTrailsClient, useTrailsSendTransaction };

package/dist/hooks/index.js

@@ -1,67 +1 @@
-"use client";
-import { useGetSequenceMetadataTokenImageUrl as o, useGetTokenImageUrl as t, useSupportedTokens as r, useTokenAddress as s, useTokenInfo as n, useTokenList as i } from "../query/token.hooks.js";
-import { useExchangeRate as m, useFiatCurrencyList as a } from "../query/fiat.hooks.js";
-import { useIndexerGatewayClient as p } from "../indexerClient.js";
-import { useAccountTransactionHistory as l } from "../transactions.js";
-import { usePublicClient as d, useSupportedChains as I } from "../query/chains.hooks.js";
-import { useCommitIntent as C, useExecuteIntent as y } from "../mutations.js";
-import { useResolveActions as v } from "../actions/hooks/useResolveActions.js";
-import { useQuote as M } from "./useQuote.js";
-import { MIN_REFETCH_INTERVAL as S, useAccountTotalBalanceUsd as B, useHasSufficientBalanceToken as P, useHasSufficientBalanceUsd as h, useTokenBalances as H, useTokenBalancesForMultipleAccounts as x } from "../query/balance.hooks.js";
-import { useTokenPrice as L, useTokenPrices as U } from "../query/price.hooks.js";
-import { useOnrampClient as F } from "../onrampClient.js";
-import { useTrailsClient as O } from "../trailsClient.js";
-import { useCountryCode as b, useCountryList as q } from "../query/geo.hooks.js";
-import { useIntentReceiptMonitor as K } from "../intentReceiptMonitor.js";
-import { useEarnMarkets as V } from "../actions/hooks/useEarnMarkets.js";
-import { useEarnBalances as j } from "../actions/hooks/useEarnBalances.js";
-import { useEarnProviders as D } from "../actions/hooks/useEarnProviders.js";
-import { useTrailsSendTransaction as X } from "./useTrailsSendTransaction.js";
-import { useIntentTransactionHistory as Z } from "./useIntentTransactionHistory.js";
-import { useGetIntent as ee } from "./useGetIntent.js";
-import { useMeldPaymentMethods as te, useMeldServiceProviders as re } from "../query/meld.hooks.js";
-import { useIntentRecover as ne, useIntentRecoverWithAddress as ie, useKeymachineIntentRecovery as ue } from "../recover.js";
-import { useOfflineIntentRecovery as ae } from "../offlineRecovery.js";
-export {
-  S as MIN_REFETCH_INTERVAL,
-  B as useAccountTotalBalanceUsd,
-  l as useAccountTransactionHistory,
-  C as useCommitIntent,
-  b as useCountryCode,
-  q as useCountryList,
-  j as useEarnBalances,
-  V as useEarnMarkets,
-  D as useEarnProviders,
-  m as useExchangeRate,
-  y as useExecuteIntent,
-  a as useFiatCurrencyList,
-  ee as useGetIntent,
-  o as useGetSequenceMetadataTokenImageUrl,
-  t as useGetTokenImageUrl,
-  P as useHasSufficientBalanceToken,
-  h as useHasSufficientBalanceUsd,
-  p as useIndexerGatewayClient,
-  K as useIntentReceiptMonitor,
-  ne as useIntentRecover,
-  ie as useIntentRecoverWithAddress,
-  Z as useIntentTransactionHistory,
-  ue as useKeymachineIntentRecovery,
-  te as useMeldPaymentMethods,
-  re as useMeldServiceProviders,
-  ae as useOfflineIntentRecovery,
-  F as useOnrampClient,
-  d as usePublicClient,
-  M as useQuote,
-  v as useResolveActions,
-  I as useSupportedChains,
-  r as useSupportedTokens,
-  s as useTokenAddress,
-  H as useTokenBalances,
-  x as useTokenBalancesForMultipleAccounts,
-  n as useTokenInfo,
-  i as useTokenList,
-  L as useTokenPrice,
-  U as useTokenPrices,
-  O as useTrailsClient,
-  X as useTrailsSendTransaction
-};
+"use client";import{$ as e,$t as t,B as n,Dn as r,En as i,F as a,Fn as o,Ft as s,Gt as c,H as l,I as u,In as d,It as f,J as p,Kt as m,L as h,Lt as g,Mn as _,Mt as v,Nn as y,Nt as b,Pn as x,Pt as S,Q as C,Qt as w,Rt as T,Tt as E,U as D,Ut as O,Wt as k,X as A,Y as j,Z as M,ir as N,it as P,jn as F,jt as I,k as L,nt as R,q as z,z as B}from"../src-Cy3oxYgV.js";export{b as MIN_REFETCH_INTERVAL,S as useAccountTotalBalanceUsd,w as useAccountTransactionHistory,c as useCommitIntent,C as useCountryCode,e as useCountryList,j as useEarnBalances,A as useEarnMarkets,p as useEarnProviders,i as useExchangeRate,m as useExecuteIntent,r as useFiatCurrencyList,l as useGetIntent,F as useGetSequenceMetadataTokenImageUrl,_ as useGetTokenImageUrl,s as useHasSufficientBalanceToken,f as useHasSufficientBalanceUsd,t as useIndexerGatewayClient,M as useIntentReceiptMonitor,a as useIntentRecover,u as useIntentRecoverWithAddress,D as useIntentTransactionHistory,h as useKeymachineIntentRecovery,B as useMeldPaymentMethods,n as useMeldServiceProviders,L as useOfflineIntentRecovery,E as useOnrampClient,R as usePublicClient,O as useQuote,k as useResolveActions,P as useSupportedChains,y as useSupportedTokens,x as useTokenAddress,g as useTokenBalances,T as useTokenBalancesForMultipleAccounts,o as useTokenInfo,d as useTokenList,I as useTokenPrice,v as useTokenPrices,N as useTrailsClient,z as useTrailsSendTransaction};

package/dist/hydrate/index.d.ts

@@ -1,8 +1,196 @@
-export type { HydrateDataSource, RuntimeHydrateDataSource, ExplicitHydrateDataSource, CalldataSelector, ByteRange, PayloadSelector, HydrateCallLike, } from './types.js';
-export { HYDRATE_PROXY_ADDRESS } from './constants.js';
-export { HydrateSource } from './source.js';
-export { HydrateSelector } from './selectors.js';
-export { HydrateBuilder, type HydrateAbiArgSpec, type HydrateAbiCalldataPatch, type HydrateCalldataPatch, type HydrateCallData, type HydrateDataSpec, type HydrateCallParams, } from './builder.js';
-export { decodeHydrateExecuteAndSweepCalldata, decodeHydrateExecuteCalldata, encodeHydrateExecuteAndSweepCalldata, encodeHydrateExecuteCalldata, hydrateFunctionsAbi, type EncodeHydrateExecuteCalldataParams, type EncodeHydrateExecuteCalldataWithPacked, type EncodeHydrateExecuteCalldataWithPayload, type EncodeHydrateExecuteCalldataWithSingleCall, type EncodeHydrateExecuteAndSweepCalldataParams, type DecodeHydrateExecuteCalldataResult, type DecodeHydrateExecuteAndSweepCalldataResult, } from './encodeExecute.js';
-export { createHydratePayload, encodeMulticallHydrateExecute, type HydrateTypeData, } from './multicall.js';
-//# sourceMappingURL=index.d.ts.map
+"use client";
+
+import { x as HydrateTypeData } from "../types-BK0WkVnx.js";
+import { a as EncodeHydrateExecuteAndSweepCalldataParams, c as EncodeHydrateExecuteCalldataWithPayload, d as decodeHydrateExecuteCalldata, f as encodeHydrateExecuteAndSweepCalldata, i as DecodeHydrateExecuteCalldataResult, l as EncodeHydrateExecuteCalldataWithSingleCall, m as hydrateFunctionsAbi, n as encodeMulticallHydrateExecute, o as EncodeHydrateExecuteCalldataParams, p as encodeHydrateExecuteCalldata, r as DecodeHydrateExecuteAndSweepCalldataResult, s as EncodeHydrateExecuteCalldataWithPacked, t as createHydratePayload, u as decodeHydrateExecuteAndSweepCalldata } from "../multicall-BCUHt_9t.js";
+import { Payload } from "@0xsequence/wallet-primitives";
+import { Address, Bytes, Hex } from "ox";
+import { AbiFunction as AbiFunction$1 } from "ox/AbiFunction";
+
+//#region src/hydrate/types.d.ts
+type ExplicitHydrateDataSource = "self" | Address.Address;
+type RuntimeHydrateDataSource = "msg.sender" | "tx.origin";
+type HydrateDataSource = ExplicitHydrateDataSource | RuntimeHydrateDataSource;
+interface CalldataSelector {
+  offset: number;
+  size: number;
+}
+interface ByteRange {
+  callIndex: number;
+  offset: number;
+  size: number;
+}
+type HydrateCallLike = {
+  data: Hex.Hex;
+};
+interface PayloadSelector {
+  resolve(calls: readonly HydrateCallLike[]): ByteRange[];
+  toString(): string;
+}
+//#endregion
+//#region src/hydrate/constants.d.ts
+declare const HYDRATE_PROXY_ADDRESS: `0x${string}`;
+//#endregion
+//#region src/hydrate/source.d.ts
+/**
+ * Helper constructors for hydrate runtime sources.
+ */
+declare const HydrateSource: {
+  self(): ExplicitHydrateDataSource;
+  msgSender(): RuntimeHydrateDataSource;
+  txOrigin(): RuntimeHydrateDataSource;
+  address(address: HydrateDataSource): ExplicitHydrateDataSource;
+};
+//#endregion
+//#region src/hydrate/selectors.d.ts
+declare class PathBuilder {
+  private readonly steps;
+  callData(callIndex: number): this;
+  slice(offset: number, size: number): this;
+  abi(functionAbi: string | AbiFunction$1): this;
+  argSlot(arg: number | string): this;
+  argBytesData(arg: number | string): this;
+  encodedCallsPayload(): this;
+  encodedCallData(index: number): this;
+  asSelector(): PayloadSelector;
+}
+declare const HydrateSelector: {
+  readonly offset: (offset: number, size: number) => CalldataSelector;
+  readonly range: (callIndex: number, offset: number, size: number) => PayloadSelector;
+  readonly path: () => PathBuilder;
+  /**
+   * Calldata span for a static ABI argument (`address`, `uint256`, `bool`,
+   * fixed arrays, static tuples, etc.). Offset and size follow standard ABI
+   * head encoding. Not supported: dynamic tuples (tuples with any dynamic
+   * component), `bytes`, `string`, unbounded `T[]`, and fixed-length arrays
+   * whose element type is dynamic — use `offset` or the path selector API.
+   */
+  readonly argument: (functionAbi: string | AbiFunction$1, arg: number | string) => CalldataSelector;
+};
+//#endregion
+//#region src/hydrate/builder.d.ts
+type HydrateBuilderInput = HydrateCallLike[] | Payload.Calls;
+/** Patch an `address` word in inner-call calldata at `selector` (wire: `address`). */
+type HydrateDataAddressSpec = {
+  kind: "address";
+  callIndex: number;
+  selector: CalldataSelector | PayloadSelector;
+  address: HydrateDataSource;
+};
+/** Patch a `uint256` with native balance for `address` (wire: `balance`). */
+type HydrateDataBalanceSpec = {
+  kind: "balance";
+  callIndex: number;
+  selector: CalldataSelector | PayloadSelector;
+  address: HydrateDataSource;
+};
+/** Patch a `uint256` with `IERC20(token).balanceOf(holder)` (wire: `erc20Balance`, holder in `address`). */
+type HydrateDataErc20BalanceSpec = {
+  kind: "erc20Balance";
+  callIndex: number;
+  selector: CalldataSelector | PayloadSelector;
+  token: Address.Address;
+  address: HydrateDataSource;
+};
+/** Patch a `uint256` with `IERC20(token).allowance(owner, spender)` (wire: `erc20Allowance`). */
+type HydrateDataErc20AllowanceSpec = {
+  kind: "erc20Allowance";
+  callIndex: number;
+  selector: CalldataSelector | PayloadSelector;
+  address: HydrateDataSource;
+  token: Address.Address;
+  spender: HydrateDataSource;
+};
+/**
+ * Calldata patch for one inner call: includes `callIndex` for the builder.
+ * Each encoded hydrate command omits `callIndex`; {@link HydrateBuilder.build}
+ * prefixes it once per section.
+ */
+type HydrateDataSpec = HydrateDataAddressSpec | HydrateDataBalanceSpec | HydrateDataErc20BalanceSpec | HydrateDataErc20AllowanceSpec;
+/** One explicit selector-based patch when {@link HydrateCallData} is an array (no `callIndex`). */
+type HydrateCalldataPatch = Omit<HydrateDataAddressSpec, "callIndex"> | Omit<HydrateDataBalanceSpec, "callIndex"> | Omit<HydrateDataErc20BalanceSpec, "callIndex"> | Omit<HydrateDataErc20AllowanceSpec, "callIndex">;
+/** Per-argument hydration for {@link HydrateBuilder.hydrateCall} (no `callIndex` / selector). */
+type HydrateAbiArgSpec = {
+  kind: "address";
+  address: HydrateDataSource;
+} | {
+  kind: "balance";
+  address: HydrateDataSource;
+} | {
+  kind: "erc20Balance";
+  token: Address.Address;
+  address: HydrateDataSource;
+} | {
+  kind: "erc20Allowance";
+  address: HydrateDataSource;
+  token: Address.Address;
+  spender: HydrateDataSource;
+};
+/** ABI-driven calldata patches: function + argument names → {@link HydrateAbiArgSpec}. */
+type HydrateAbiCalldataPatch = {
+  /** Function signature string or `AbiFunction` from `ox`. */function: string | AbiFunction$1;
+  args: Record<string, HydrateAbiArgSpec>;
+};
+/**
+ * `hydrateCall` `data`: either ABI argument patches, or an ordered list of explicit
+ * selector patches (offsets, {@link HydrateSelector.path}, etc.).
+ */
+type HydrateCallData = HydrateAbiCalldataPatch | ReadonlyArray<HydrateCalldataPatch>;
+/** Parameters for {@link HydrateBuilder.hydrateCall}. */
+type HydrateCallParams = {
+  callIndex: number;
+  data?: HydrateCallData;
+  to?: HydrateDataSource;
+  value?: HydrateDataSource;
+};
+/**
+ * Builds HydrateProxy `hydratePayload` bytes from calldata selectors, without
+ * hand-encoding command flags or offsets. Sections are emitted in ascending
+ * call index, matching HydrateProxy execution order.
+ *
+ * Create instances with {@link HydrateBuilder.from}. Use {@link HydrateBuilder.hydrateCall}
+ * for all hydrations (`data` as ABI args or explicit patch list, `to`, `value`).
+ */
+declare class HydrateBuilder {
+  private readonly calls;
+  private readonly byCall;
+  /**
+   * @param callsInput Ordered `{ data }` entries (array index = packed call
+   * index), or v3 `Payload.Calls` (only each `call.data` is used).
+   */
+  private constructor();
+  /**
+   * Start a builder from ordered `{ data }` entries (index = packed call index),
+   * or from v3 `Payload.Calls` (only each `call.data` is used).
+   */
+  static from(callsInput: HydrateBuilderInput): HydrateBuilder;
+  private data;
+  /**
+   * Queue hydrations for one packed call. `data` is either ABI `function` + `args`,
+   * or an ordered list of explicit selector patches; optional `to` / `value`.
+   */
+  hydrateCall(params: HydrateCallParams): this;
+  private to;
+  private value;
+  private appendCommand;
+  /** Resolve `selector` to a single byte range on `callIndex`, with bounds checks. */
+  private resolveSelector;
+  /** Resolve `selector` for `callIndex`; ensures size is 20 or 32 bytes. */
+  private resolveAddressSelector;
+  /** Resolve `selector` for `callIndex`; ensures a 32-byte word within calldata. */
+  private resolveUint256Selector;
+  /** Ensures selector targets 20- or 32-byte address encoding. */
+  private assertAddressSelector;
+  /** Ensures selector spans a full 32-byte ABI word. */
+  private assertUint256Selector;
+  /** Ensures selector fits within the call’s calldata buffer. */
+  private assertSelectorBounds;
+  /** Ensures `index` is a valid uint8 and within `calls.length`. */
+  private assertCallIndex;
+  /**
+   * Concatenate all sections: per call index, `[tindex][commands…][0x00]`.
+   * Returns empty bytes when there are no commands.
+   */
+  build(): Bytes.Bytes;
+}
+//#endregion
+export { type ByteRange, type CalldataSelector, type DecodeHydrateExecuteAndSweepCalldataResult, type DecodeHydrateExecuteCalldataResult, type EncodeHydrateExecuteAndSweepCalldataParams, type EncodeHydrateExecuteCalldataParams, type EncodeHydrateExecuteCalldataWithPacked, type EncodeHydrateExecuteCalldataWithPayload, type EncodeHydrateExecuteCalldataWithSingleCall, type ExplicitHydrateDataSource, HYDRATE_PROXY_ADDRESS, type HydrateAbiArgSpec, type HydrateAbiCalldataPatch, HydrateBuilder, type HydrateCallData, type HydrateCallLike, type HydrateCallParams, type HydrateCalldataPatch, type HydrateDataSource, type HydrateDataSpec, HydrateSelector, HydrateSource, type HydrateTypeData, type PayloadSelector, type RuntimeHydrateDataSource, createHydratePayload, decodeHydrateExecuteAndSweepCalldata, decodeHydrateExecuteCalldata, encodeHydrateExecuteAndSweepCalldata, encodeHydrateExecuteCalldata, encodeMulticallHydrateExecute, hydrateFunctionsAbi };

package/dist/hydrate/index.js

@@ -1,19 +1 @@
-import { HYDRATE_PROXY_ADDRESS as t } from "./constants.js";
-import { HydrateSource as a } from "./source.js";
-import { HydrateSelector as o } from "./selectors.js";
-import { HydrateBuilder as l } from "./builder.js";
-import { decodeHydrateExecuteAndSweepCalldata as y, decodeHydrateExecuteCalldata as i, encodeHydrateExecuteAndSweepCalldata as H, encodeHydrateExecuteCalldata as p, hydrateFunctionsAbi as u } from "./encodeExecute.js";
-import { createHydratePayload as E, encodeMulticallHydrateExecute as f } from "./multicall.js";
-export {
-  t as HYDRATE_PROXY_ADDRESS,
-  l as HydrateBuilder,
-  o as HydrateSelector,
-  a as HydrateSource,
-  E as createHydratePayload,
-  y as decodeHydrateExecuteAndSweepCalldata,
-  i as decodeHydrateExecuteCalldata,
-  H as encodeHydrateExecuteAndSweepCalldata,
-  p as encodeHydrateExecuteCalldata,
-  f as encodeMulticallHydrateExecute,
-  u as hydrateFunctionsAbi
-};
+import{a as e,c as t,d as n,i as r,l as i,n as a,o,r as s,s as c,t as l,u}from"../hydrate-QyWqQfec.js";export{n as HYDRATE_PROXY_ADDRESS,t as HydrateBuilder,i as HydrateSelector,u as HydrateSource,l as createHydratePayload,s as decodeHydrateExecuteAndSweepCalldata,r as decodeHydrateExecuteCalldata,e as encodeHydrateExecuteAndSweepCalldata,o as encodeHydrateExecuteCalldata,a as encodeMulticallHydrateExecute,c as hydrateFunctionsAbi};

package/dist/hydrate-QyWqQfec.js

@@ -0,0 +1 @@
+import{t as e}from"./defineProperty-BbfpZ9Tg.js";import{Payload as t}from"@0xsequence/wallet-primitives";import{encodeFunctionData as n,erc20Abi as r,zeroAddress as i}from"viem";import{AbiFunction as a,Address as o,Bytes as s,Hex as c}from"ox";var l=class extends Error{constructor(t,n,r){super(n,r===void 0?void 0:{cause:r}),e(this,`code`,void 0),this.name=`PlaceholderError`,this.code=t}};const u=114316045351081986197366228715807272115562181347258027827511447451103061843027n,d=`0xd80d3a37a85094663c36c062e5ef689f2bf54fca`;function f(e,t){let n=t.toString(16).padStart(64,`0`),r=s.fromHex(`0x${n}`),i=s.fromHex(e),a=[];for(let e=0;e+32<=i.length;e++){let t=!0;for(let n=0;n<32;n++)if(i[e+n]!==r[n]){t=!1;break}t&&a.push(e)}return a}function p(e){return e>=4&&(e-4)%32==0}function m(e){let t=`000000000000000000000000${d.slice(2)}`.toLowerCase(),n=e.toLowerCase(),r=(n.length-2)/2,i=[];for(let e=4;e+32<=r;e+=32){let r=2+e*2;n.slice(r,r+64)===t&&i.push(e+12)}return i}function h(e,t){let n=g(e,t);if(n.length>1)throw new l(`MULTIPLE_AMOUNT_SLOTS`,`Ambiguous placeholder match; expected exactly one amount slot, found ${n.length}`);return n.length===1?n[0]:-1}function g(e,t){let n=t.toString(16).padStart(64,`0`).toLowerCase(),r=e.toLowerCase(),i=(r.length-2)/2,a=[];for(let e=4;e+32<=i;e+=32){let t=2+e*2;r.slice(t,t+64)===n&&a.push(e)}if(a.length===0){let n=f(e,t);if(n.some(e=>!p(e)))throw new l(`INVALID_AMOUNT_OFFSET`,`Invalid placeholder offset ${n.find(e=>!p(e))}; expected a 32-byte ABI word offset`)}return a}function _(e,t){if(t<=0n)return null;if(t===114316045351081986197366228715807272115562181347258027827511447451103061843027n)return e;let n=g(e,t);if(n.length===0)return null;let r=u.toString(16).padStart(64,`0`),i=e;for(let e of n){let t=2+e*2;i=i.slice(0,t)+r+i.slice(t+64)}return i}function v(e){return!e||e===`0x`||!c.validate(e,{strict:!0})?!1:g(e,u).length>0}function y(e,t){if(!e||e===`0x`)return e;if(!t||t===``)return console.warn(`replacePlaceholderInCalldata: Amount is empty, returning original calldata`),e;let n;try{n=BigInt(t)}catch(n){return console.warn(`replacePlaceholderInCalldata: Invalid amount "${t}", returning original calldata`,n),e}if(n<0n)return console.warn(`replacePlaceholderInCalldata: Amount cannot be negative (${t}), returning original calldata`),e;if(n>BigInt(`0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff`))return console.warn(`replacePlaceholderInCalldata: Amount exceeds uint256 max (${t}), returning original calldata`),e;let r=n.toString(16).padStart(64,`0`),i=g(e,u);if(i.length===0)return e;let a=s.fromHex(e),o=s.fromHex(`0x${r}`);for(let e of i)a.set(o,e);return s.toHex(a)}const b=o.from(`0x000000004f702C8398e158108937814d074cD74b`),x={self(){return`self`},msgSender(){return`msg.sender`},txOrigin(){return`tx.origin`},address(e){if(e===`self`||e===`msg.sender`||e===`tx.origin`)throw Error(`HydrateSource.address() requires an explicit 0x address or HydrateSource.self().`);return o.assert(e),e}};function S(e){if(typeof e==`string`){let t=a.from(e);if(t.type!==`function`)throw Error(`Expected function ABI signature`);return t}return e}function C(e,t){if(typeof t==`number`){if(!Number.isInteger(t)||t<0||t>=e.length)throw Error(`Invalid argument index ${t} for function with ${e.length} inputs`);return t}let n=e.findIndex(e=>e.name===t);if(n<0)throw Error(`Argument '${t}' not found in function inputs`);return n}function w(e,t){let n=e[t]?.type;if(!n)throw Error(`Input at index ${t} has no ABI type`);return n}function T(e,t){let n=e.slice(t,t+32);if(n.length!==32)throw Error(`Expected 32-byte word`);return s.toBigInt(n)}function E(e){let t=e.match(/^(.*)\[(\d+)?\]$/);return t?[t[2]?Number(t[2]):null,t[1]]:void 0}function D(e){let{type:t}=e;if(t===`string`||t===`bytes`||t.endsWith(`[]`))return!0;if(t===`tuple`)return e.components?.some(D)??!1;let n=E(t);return!!(n&&D({...e,type:n[1]}))}function O(e){if(D(e))return 1;if(e.type===`tuple`){let t=e.components;if(!t?.length)throw Error(`tuple ABI parameter missing components`);let n=0;for(let e of t)n+=O(e);return n}let t=E(e.type);if(t){let[n,r]=t,i=O({...e,type:r});return n===null?1:i*n}return 1}function k(e,t){let n=e.inputs,r=n[t];if(!r)throw Error(`Argument index ${t} out of bounds`);if(D(r))throw Error(`Argument ${t} is dynamic; no static slot`);let i=0;for(let e=0;e<t;e++){let t=n[e];if(!t)throw Error(`Unexpected missing ABI input`);i+=O(t)}let a=O(r);return{start:4+i*32,length:a*32}}function A(e,t,n){let r=t.inputs,i=r[n];if(!i)throw Error(`Argument index ${n} out of bounds`);if(i.type!==`bytes`&&i.type!==`string`)throw Error(`Argument ${n} must be bytes or string`);let a=0;for(let e=0;e<n;e++){let t=r[e];if(!t)throw Error(`Unexpected missing ABI input`);a+=O(t)}let o=4+a*32;if(o+32>e.length)throw Error(`Calldata too short`);let s=Number(T(e,o));if(!Number.isInteger(s)||s<0)throw Error(`Invalid dynamic offset: ${s}`);let c=4+s;if(c+32>e.length)throw Error(`Calldata too short for tail`);let l=Number(T(e,c));if(!Number.isInteger(l)||l<0)throw Error(`Invalid dynamic data length: ${l}`);let u=c+32;if(u+l>e.length)throw Error(`Dynamic bytes data out of bounds`);return{start:u,length:l}}function j(e){let t=0;if(e.length<1)throw Error(`Invalid packed data: missing globalFlag`);let n=s.toNumber(e.slice(t,t+1));t+=1,(n&1)!=1&&(t+=20),t+=n>>1&7;let r=1;if((n&16)!=16){let i=(n&32)==32?2:1;if(t+i>e.length)throw Error(`Invalid packed data: not enough bytes for callsCount`);r=s.toNumber(e.slice(t,t+i)),t+=i}let i=[];for(let n=0;n<r;n++){if(t+1>e.length)throw Error(`Invalid packed data: missing call flags`);let n=s.toNumber(e.slice(t,t+1));if(t+=1,(n&1)!=1&&(t+=20),(n&2)==2&&(t+=32),(n&4)==4){if(t+3>e.length)throw Error(`Invalid packed data: missing data length`);let n=s.toNumber(e.slice(t,t+3));if(t+=3,t+n>e.length)throw Error(`Invalid packed data: call data out of bounds`);i.push({start:t,len:n}),t+=n}else i.push({start:-1,len:0});if((n&8)==8&&(t+=32),t>e.length)throw Error(`Invalid packed data: overflow`)}return{globalFlag:n,numCalls:r,callData:i}}function M(e,t){let n=e[t.callIndex]?.data;if(!n||!c.validate(n))throw Error(`Invalid calldata at call index ${t.callIndex}`);let r=s.fromHex(n);if(t.offset<0||t.size<0||t.offset+t.size>r.length)throw Error(`Range out of bounds for call ${t.callIndex}`);return r.slice(t.offset,t.offset+t.size)}var N=class{constructor(t){e(this,`steps`,void 0),this.steps=t}resolve(e){let t={ranges:[]};for(let n of this.steps)t=n.apply(e,t);if(t.ranges.length===0)throw Error(`Path resolved to empty ranges`);return t.ranges}toString(){return`path(${this.steps.map(e=>e.description).join(` -> `)})`}},ee=class{constructor(){e(this,`steps`,[])}callData(e){if(!Number.isInteger(e)||e<0)throw Error(`Invalid call index: ${e}`);return this.steps.push({description:`calldata(${e})`,apply(t){let n=t[e]?.data;if(!n||!c.validate(n))throw Error(`Call ${e} has invalid calldata`);return{ranges:[{callIndex:e,offset:0,size:s.fromHex(n).length}]}}}),this}slice(e,t){return this.steps.push({description:`slice(${e},${t})`,apply(n,r){if(r.ranges.length===0)throw Error(`slice() has no active ranges`);return{ranges:r.ranges.map(n=>{if(e<0||t<0||e+t>n.size)throw Error(`slice() out of bounds`);return{callIndex:n.callIndex,offset:n.offset+e,size:t}})}}}),this}abi(e){let t=S(e);return this.steps.push({description:`abi(${t.name})`,apply(e,n){if(n.ranges.length===0)throw Error(`abi() has no active ranges`);let r=a.getSelector(t);for(let i of n.ranges){let n=M(e,i);if(n.length<4||s.toHex(n.slice(0,4)).toLowerCase()!==r.toLowerCase())throw Error(`ABI selector mismatch for ${t.name}`)}return{ranges:n.ranges,method:t}}}),this}argSlot(e){return this.steps.push({description:`argslot(${String(e)})`,apply(t,n){if(!n.method)throw Error(`argSlot() requires abi() binding`);let r=n.method.inputs,i=C(r,e),{start:a,length:o}=k(n.method,i);return{ranges:n.ranges.map(e=>{if(a+o>e.size)throw Error(`argSlot() out of bounds`);return{callIndex:e.callIndex,offset:e.offset+a,size:o}})}}}),this}argBytesData(e){return this.steps.push({description:`argbytes(${String(e)})`,apply(t,n){if(!n.method)throw Error(`argBytesData() requires abi() binding`);let r=n.method.inputs,i=C(r,e);return{ranges:n.ranges.map(e=>{let{start:r,length:a}=A(M(t,e),n.method,i);return{callIndex:e.callIndex,offset:e.offset+r,size:a}})}}}),this}encodedCallsPayload(){return this.steps.push({description:`encodedcallspayload()`,apply(e,t){if(t.ranges.length===0)throw Error(`encodedCallsPayload() has no active ranges`);return{ranges:t.ranges}}}),this}encodedCallData(e){return this.steps.push({description:`encodedcalldata(${e})`,apply(t,n){if(!Number.isInteger(e)||e<0)throw Error(`Invalid encoded call index`);if(n.ranges.length===0)throw Error(`encodedCallData() has no active ranges`);return{ranges:n.ranges.map(n=>{let r=j(M(t,n));if(e>=r.callData.length)throw Error(`encodedCallData(${e}) out of range`);let i=r.callData[e];if(!i||i.start<0)throw Error(`encodedCallData(${e}) has no calldata`);return{callIndex:n.callIndex,offset:n.offset+i.start,size:i.len}})}}}),this}asSelector(){return new N([...this.steps])}};const P={offset(e,t){if(!Number.isInteger(e)||e<0)throw Error(`Invalid calldata offset: ${e}`);if(!Number.isInteger(t)||t<=0)throw Error(`Invalid selector size: ${t}`);return{offset:e,size:t}},range(e,t,n){if(!Number.isInteger(e)||e<0)throw Error(`Invalid call index: ${e}`);let r=this.offset(t,n);return{resolve(t){let n=t[e]?.data;if(!n||!c.validate(n))throw Error(`Invalid calldata at call index ${e}`);let i=s.fromHex(n).length;if(r.offset+r.size>i)throw Error(`Range out of bounds for call ${e}`);return[{callIndex:e,offset:r.offset,size:r.size}]},toString(){return`range(${e},${t},${n})`}}},path(){return new ee},argument(e,t){let n=S(e),r=n.inputs,i=C(r,t),a=r[i];if(!a)throw Error(`Argument index ${i} out of bounds`);if(D(a)){let e=w(r,i);throw Error(`Argument '${String(t)}' has dynamic type '${e}'. Use HydrateSelector.offset(...) or path-based selectors.`)}let{start:o,length:s}=k(n,i);return{offset:o,size:s}}};function F(e){if(e===`self`)return 0;if(e===`msg.sender`)return 1;if(e===`tx.origin`)return 2;if(o.validate(e))return 3;throw Error(`Invalid hydrate data source`)}function I(e){if(!Number.isInteger(e)||e<0||e>65535)throw Error(`Calldata offset out of uint16 range: ${e}`)}function L(e){return I(e),s.fromNumber(e,{size:2})}function R(e){return e.offset+e.size}function z(e){let t=0;if(e.type===`address`)t=16;else if(e.type===`balance`)t=32;else if(e.type===`erc20Balance`)t=48;else if(e.type===`erc20Allowance`)t=64;else if(e.type===`to`)t=80;else if(e.type===`value`)t=96;else throw Error(`Unknown hydrate type`);t|=F(e.address);let n=[s.fromNumber(t,{size:1})];if(o.validate(e.address)&&n.push(s.fromHex(e.address)),e.type===`address`||e.type===`balance`||e.type===`erc20Balance`||e.type===`erc20Allowance`){if(n.push(L(e.calldataOffset)),e.type===`erc20Balance`)n.push(s.fromHex(e.token));else if(e.type===`erc20Allowance`){n.push(s.fromHex(e.token));let t=F(e.spender);n.push(s.fromNumber(t,{size:1})),o.validate(e.spender)&&n.push(s.fromHex(e.spender))}}return s.concat(...n)}function B(e){return!Array.isArray(e)}function V(e){if(typeof e==`string`){let t=a.from(e);if(t.type!==`function`)throw Error(`Expected function ABI signature`);return t}return e}function H(e,t){if(typeof t==`number`){if(!Number.isInteger(t)||t<0||t>=e.length)throw Error(`Invalid argument index ${t} for function with ${e.length} inputs`);return t}let n=e.findIndex(e=>e.name===t);if(n<0)throw Error(`Argument '${t}' not found in function inputs`);return n}function U(e,t,n){let r=t.type;if(n.kind===`address`){if(r!==`address`)throw Error(`hydrateCall(): cannot use kind "address" for argument "${e}"; ABI type is ${r}`);return}if(!/^(u?int\d+|uint|int)$/.test(r))throw Error(`hydrateCall(): cannot use kind "${n.kind}" for argument "${e}"; expected a uint/int ABI head word, got ${r}`)}var W=class t{constructor(t){e(this,`calls`,void 0),e(this,`byCall`,new Map),this.calls=Array.isArray(t)?t:t.calls.map(e=>({data:e.data??`0x`}))}static from(e){return new t(e)}data(e){let{callIndex:t}=e;switch(this.assertCallIndex(t),e.kind){case`address`:{let{selector:n,address:r}=e,i=this.resolveAddressSelector(t,n),a=i.size===32?i.offset+12:i.offset;this.appendCommand(t,z({type:`address`,address:r,calldataOffset:a}));break}case`balance`:{let{selector:n,address:r}=e,i=this.resolveUint256Selector(t,n);this.appendCommand(t,z({type:`balance`,address:r,calldataOffset:i.offset}));break}case`erc20Balance`:{let{selector:n,token:r,address:i}=e,a=this.resolveUint256Selector(t,n);o.assert(r),this.appendCommand(t,z({type:`erc20Balance`,token:r,address:i,calldataOffset:a.offset}));break}case`erc20Allowance`:{let{selector:n,address:r,token:i,spender:a}=e,s=this.resolveUint256Selector(t,n);o.assert(i),this.appendCommand(t,z({type:`erc20Allowance`,address:r,token:i,spender:a,calldataOffset:s.offset}));break}}return this}hydrateCall(e){let{callIndex:t,data:n,to:r,value:i}=e,a=!1;if(n!==void 0)if(B(n)){if(Object.keys(n.args).length===0)throw Error(`hydrateCall(): data.args must not be empty`);a=!0}else{if(n.length===0)throw Error(`hydrateCall(): data patch list must not be empty`);a=!0}let o=r!==void 0,s=i!==void 0;if(!a&&!o&&!s)throw Error(`hydrateCall() requires at least one of data, to, or value`);if(this.assertCallIndex(t),n!==void 0)if(B(n)){let{function:e,args:r}=n,i=Object.entries(r),a=V(e),o=a.inputs,s=i.map(([e,t])=>{let n=H(o,e),r=o[n];if(!r)throw Error(`Argument index ${n} out of bounds`);return U(e,r,t),{spec:t,selector:P.argument(a,e)}});s.sort((e,t)=>e.selector.offset-t.selector.offset);for(let{spec:e,selector:n}of s)this.data({...e,callIndex:t,selector:n})}else for(let e of n)this.data({...e,callIndex:t});return o&&this.to({callIndex:t,address:r}),s&&this.value({callIndex:t,address:i}),this}to(e){let{callIndex:t,address:n}=e;return this.assertCallIndex(t),this.appendCommand(t,z({type:`to`,address:n})),this}value(e){let{callIndex:t,address:n}=e;return this.assertCallIndex(t),this.appendCommand(t,z({type:`value`,address:n})),this}appendCommand(e,t){let n=this.byCall.get(e)??[];n.push(t),this.byCall.set(e,n)}resolveSelector(e,t){if(`resolve`in t){let n=t.resolve(this.calls);if(n.length!==1)throw Error(`Selector must resolve exactly one range for call ${e}, got ${n.length}`);let r=n[0];if(!r||r.callIndex!==e)throw Error(`Selector resolved to call ${r?.callIndex??`unknown`}; expected ${e}`);return this.assertSelectorBounds(e,{offset:r.offset,size:r.size}),r}return this.assertSelectorBounds(e,t),{callIndex:e,offset:t.offset,size:t.size}}resolveAddressSelector(e,t){let n=this.resolveSelector(e,t);return this.assertAddressSelector(e,{offset:n.offset,size:n.size}),n}resolveUint256Selector(e,t){let n=this.resolveSelector(e,t);return this.assertUint256Selector(e,{offset:n.offset,size:n.size}),n}assertAddressSelector(e,t){if(t.size!==20&&t.size!==32)throw Error(`Address selector must resolve to 20 or 32 bytes, got ${t.size}`);this.assertSelectorBounds(e,t)}assertUint256Selector(e,t){if(t.size!==32)throw Error(`Uint256 selector must resolve to 32 bytes, got ${t.size}`);this.assertSelectorBounds(e,t)}assertSelectorBounds(e,t){let n=this.calls[e]?.data;if(!n||!c.validate(n))throw Error(`Invalid calldata at call index ${e}`);let r=s.fromHex(n).length;if(R(t)>r)throw Error(`Selector out of bounds for call ${e}: need ${R(t)} bytes, got ${r}`);I(t.offset)}assertCallIndex(e){if(!Number.isInteger(e)||e<0||e>255)throw Error(`Invalid call index ${e}; must be uint8`);if(e>=this.calls.length)throw Error(`Call index ${e} out of range (calls length ${this.calls.length})`)}build(){if(this.byCall.size===0)return s.from([]);let e=[],t=[...this.byCall.keys()].sort((e,t)=>e-t);for(let n of t){let t=this.byCall.get(n)??[];if(t.length!==0){e.push(s.fromNumber(n,{size:1}));for(let n of t)e.push(n);e.push(s.fromNumber(0,{size:1}))}}return e.length===0?s.from([]):s.concat(...e)}};const G=a.from(`function hydrateExecute(bytes packedPayload, bytes hydratePayload) payable`),K=a.from(`function hydrateExecuteAndSweep(bytes packedPayload, bytes hydratePayload, address sweepTarget, address[] tokensToSweep, bool sweepNative) payable`),q=[G,K];function J(e){let n;if(`packedPayload`in e)n=c.from(e.packedPayload);else if(`target`in e){let r={type:`call`,space:0n,nonce:0n,calls:[{to:e.target,data:e.calldata,value:0n,gasLimit:0n,delegateCall:!1,onlyFallback:!1,behaviorOnError:`revert`}]};n=s.toHex(t.encode(r))}else if(`payload`in e)n=s.toHex(t.encode(e.payload));else{let t=e,n=typeof t==`object`&&t&&!Array.isArray(t)&&!(t instanceof Uint8Array)?Object.keys(t).sort().join(`, `):String(t);throw Error(`encodeHydrateExecuteCalldata: invalid arguments. Expected exactly one of: \`{ packedPayload, hydratePayload }\`, \`{ target, calldata, hydratePayload }\`, or \`{ payload, hydratePayload }\`. Received keys: ${n}`)}return a.encodeData(G,[n,c.from(e.hydratePayload)])}function Y(e){return a.encodeData(K,[c.from(e.packedPayload),c.from(e.hydratePayload),e.sweepTarget,e.tokensToSweep,e.sweepNative])}function X(e){let[t,n]=a.decodeData(G,e);return{packedPayload:t,hydratePayload:n}}function Z(e){let[t,n,r,i,o]=a.decodeData(K,e);return{packedPayload:t,hydratePayload:n,sweepTarget:r,tokensToSweep:i,sweepNative:o}}const Q=`0x095ea7b3`;function te(e,t){let n=2+t*2,r=n+64,i=e.slice(0,n),a=e.slice(r);return`${i}${`0`.repeat(64)}${a}`}function ne(e){return e.length<138||e.slice(0,10).toLowerCase()!==Q?null:`0x${e.slice(34,74)}`}function re(e,t,n){let r=n.toLowerCase();for(let n=t+1;n<e.length;n++)if(e[n].to.toLowerCase()===r)return!0;return!1}function ie(e){let t=u.toString(16).padStart(64,`0`).toLowerCase(),n=d.slice(2).toLowerCase();for(let r=0;r<e.length;r++){let i=e[r].data.toLowerCase();if(i.includes(t))throw Error(`encodeMulticallHydrateExecute: call ${r} still contains an un-hydrated dynamic() amount sentinel after encoding.`);if(i.includes(n))throw Error(`encodeMulticallHydrateExecute: call ${r} still contains an un-hydrated or non-ABI-aligned self() address sentinel after encoding.`)}}function $(e,t){let n=[s.fromNumber(e,{size:1})];for(let e of t)n.push(z(e));return n.push(s.fromNumber(0)),s.concat(...n)}function ae({calls:e,token:t,sweepTarget:a}){let o=[],s=[],c=new Set,l=(e,t)=>`${e.toLowerCase()}::${t.toLowerCase()}`,d=new Set,f=!1,p=e=>{if(!e)return;let t=e.toLowerCase();if(t===i.toLowerCase()){f=!0;return}d.add(t)};for(let t=0;t<e.length;t++){let a=e[t],d=a.data;if(a.dynamicAmountToken!==void 0&&a.dynamicAmountTokens!==void 0)throw Error(`encodeMulticallHydrateExecute: use either dynamicAmountToken or dynamicAmountTokens, not both.`);if(a.dynamicAmountToken?.toLowerCase()===i.toLowerCase())throw Error(`encodeMulticallHydrateExecute: dynamicAmountToken cannot be the zero address; dynamic amount hydration is ERC-20 balance based.`);if(a.dynamicAmountTokens?.length===0)throw Error(`encodeMulticallHydrateExecute: dynamicAmountTokens cannot be empty.`);for(let e of a.dynamicAmountTokens??[])if(e.toLowerCase()===i.toLowerCase())throw Error(`encodeMulticallHydrateExecute: dynamicAmountTokens cannot contain the zero address; dynamic amount hydration is ERC-20 balance based.`);let f=d.slice(0,10).toLowerCase()===Q,h=[],_=g(d,u);if(a.dynamicAmountTokens!==void 0&&a.dynamicAmountTokens.length!==_.length)throw Error(`encodeMulticallHydrateExecute: dynamicAmountTokens length must match the number of dynamic() amount sentinels.`);if(_.length>0){let i;if(a.dynamicAmountTokens!==void 0)i=[...a.dynamicAmountTokens];else{let e;if(a.dynamicAmountToken?e=a.dynamicAmountToken:f&&(e=a.to),!e)throw Error(`encodeMulticallHydrateExecute: call contains a dynamic() amount sentinel, but no hydration source could be resolved. Set dynamicAmountToken or dynamicAmountTokens.`);i=_.map(()=>e)}for(let e of _)d=te(d,e);for(let e of i)p(e);if(d.slice(0,10).toLowerCase()===Q&&_.includes(36)){let n=a.to.toLowerCase();if(i.some(e=>e.toLowerCase()!==n))throw Error(`encodeMulticallHydrateExecute: approve(spender, dynamic()) token source must match call.to.`);let r=ne(d);if(!r||!re(e,t,r))throw Error(`encodeMulticallHydrateExecute: approve(spender, dynamic()) must be followed by a call to spender in the same batch.`);c.add(l(a.to,r))}else{let e=new Map;for(let t of i)e.set(t.toLowerCase(),t);for(let t of e.values()){if(c.has(l(t,a.to)))continue;let e=n({abi:r,functionName:`approve`,args:[a.to,0n]}),i=o.length;o.push({to:t,data:e,value:0n,gasLimit:0n,delegateCall:!1,onlyFallback:!1,behaviorOnError:`revert`}),s.push({callIndex:i,datas:[{type:`erc20Balance`,token:t,calldataOffset:36,address:x.self()}]}),c.add(l(t,a.to))}}for(let e=0;e<_.length;e++)h.push({type:`erc20Balance`,token:i[e],calldataOffset:_[e],address:x.self()})}let v=m(d);if(v.length>0){let e=d;for(let t of v){let n=2+(t-12)*2;e=e.slice(0,n)+`0`.repeat(64)+e.slice(n+64)}d=e;for(let e of v)h.push({type:`address`,address:x.self(),calldataOffset:e})}if(a.hydrateEntries?.length){h.push(...a.hydrateEntries);for(let e of a.hydrateEntries)(e.type===`erc20Balance`||e.type===`erc20Allowance`)&&p(e.token)}if(f&&p(a.to),a.sweepTokens?.length)for(let e of a.sweepTokens)p(e);let y=o.length;o.push({to:a.to,data:d,value:BigInt(a.value??0),gasLimit:0n,delegateCall:!1,onlyFallback:!1,behaviorOnError:`revert`}),h.length>0&&s.push({callIndex:y,datas:h})}let h=se(s);ie(o),p(t);let _=t.toLowerCase()===i.toLowerCase();return Y({packedPayload:oe(o),hydratePayload:h,sweepTarget:a,tokensToSweep:[...d],sweepNative:_||f})}function oe(e){let n={type:`call`,space:0n,nonce:0n,calls:e};return s.toHex(t.encode(n))}function se(e){if(e.length===0)return`0x`;let t=e.map(e=>$(e.callIndex,e.datas));return s.toHex(s.concat(...t))}export{g as _,Y as a,W as c,b as d,l as f,h as g,v as h,X as i,P as l,d as m,ae as n,J as o,u as p,Z as r,q as s,$ as t,x as u,_ as v,y};