0xtrails 0.13.2 → 0.15.0

package/dist/hydrate/encodeExecute.d.ts

@@ -0,0 +1,73 @@
+import { Payload } from '@0xsequence/wallet-primitives';
+import { Address, Bytes, Hex } from 'ox';
+export declare const hydrateFunctionsAbi: readonly [{
+    readonly name: "hydrateExecute";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "packedPayload";
+    }, {
+        readonly type: "bytes";
+        readonly name: "hydratePayload";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "hydrateExecuteAndSweep";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "packedPayload";
+    }, {
+        readonly type: "bytes";
+        readonly name: "hydratePayload";
+    }, {
+        readonly type: "address";
+        readonly name: "sweepTarget";
+    }, {
+        readonly type: "address[]";
+        readonly name: "tokensToSweep";
+    }, {
+        readonly type: "bool";
+        readonly name: "sweepNative";
+    }];
+    readonly outputs: readonly [];
+}];
+export type EncodeHydrateExecuteCalldataWithPacked = {
+    packedPayload: Bytes.Bytes | Hex.Hex;
+    hydratePayload: Bytes.Bytes | Hex.Hex;
+};
+export type EncodeHydrateExecuteCalldataWithSingleCall = {
+    target: Address.Address;
+    calldata: Hex.Hex;
+    hydratePayload: Bytes.Bytes | Hex.Hex;
+};
+export type EncodeHydrateExecuteCalldataWithPayload = {
+    payload: Payload.Calls;
+    hydratePayload: Bytes.Bytes | Hex.Hex;
+};
+export type EncodeHydrateExecuteCalldataParams = EncodeHydrateExecuteCalldataWithPacked | EncodeHydrateExecuteCalldataWithSingleCall | EncodeHydrateExecuteCalldataWithPayload;
+export type EncodeHydrateExecuteAndSweepCalldataParams = {
+    packedPayload: Bytes.Bytes | Hex.Hex;
+    hydratePayload: Bytes.Bytes | Hex.Hex;
+    sweepTarget: Address.Address;
+    tokensToSweep: Address.Address[];
+    sweepNative: boolean;
+};
+export type DecodeHydrateExecuteCalldataResult = {
+    packedPayload: Hex.Hex;
+    hydratePayload: Hex.Hex;
+};
+export type DecodeHydrateExecuteAndSweepCalldataResult = {
+    packedPayload: Hex.Hex;
+    hydratePayload: Hex.Hex;
+    sweepTarget: Address.Address;
+    tokensToSweep: Address.Address[];
+    sweepNative: boolean;
+};
+export declare function encodeHydrateExecuteCalldata(args: EncodeHydrateExecuteCalldataParams): Hex.Hex;
+export declare function encodeHydrateExecuteAndSweepCalldata(args: EncodeHydrateExecuteAndSweepCalldataParams): Hex.Hex;
+export declare function decodeHydrateExecuteCalldata(calldata: Hex.Hex): DecodeHydrateExecuteCalldataResult;
+export declare function decodeHydrateExecuteAndSweepCalldata(calldata: Hex.Hex): DecodeHydrateExecuteAndSweepCalldataResult;
+//# sourceMappingURL=encodeExecute.d.ts.map

package/dist/hydrate/encodeExecute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeExecute.d.ts","sourceRoot":"","sources":["../../src/hydrate/encodeExecute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AACvD,OAAO,EAAe,KAAK,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AAS1D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtB,CAAA;AAEV,MAAM,MAAM,sCAAsC,GAAG;IACnD,aAAa,EAAE,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAAA;IACpC,cAAc,EAAE,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAAA;CACtC,CAAA;AAED,MAAM,MAAM,0CAA0C,GAAG;IACvD,MAAM,EAAE,OAAO,CAAC,OAAO,CAAA;IACvB,QAAQ,EAAE,GAAG,CAAC,GAAG,CAAA;IACjB,cAAc,EAAE,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAAA;CACtC,CAAA;AAED,MAAM,MAAM,uCAAuC,GAAG;IACpD,OAAO,EAAE,OAAO,CAAC,KAAK,CAAA;IACtB,cAAc,EAAE,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAAA;CACtC,CAAA;AAED,MAAM,MAAM,kCAAkC,GAC1C,sCAAsC,GACtC,0CAA0C,GAC1C,uCAAuC,CAAA;AAE3C,MAAM,MAAM,0CAA0C,GAAG;IACvD,aAAa,EAAE,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAAA;IACpC,cAAc,EAAE,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAAA;IACrC,WAAW,EAAE,OAAO,CAAC,OAAO,CAAA;IAC5B,aAAa,EAAE,OAAO,CAAC,OAAO,EAAE,CAAA;IAChC,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,kCAAkC,GAAG;IAC/C,aAAa,EAAE,GAAG,CAAC,GAAG,CAAA;IACtB,cAAc,EAAE,GAAG,CAAC,GAAG,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,0CAA0C,GAAG;IACvD,aAAa,EAAE,GAAG,CAAC,GAAG,CAAA;IACtB,cAAc,EAAE,GAAG,CAAC,GAAG,CAAA;IACvB,WAAW,EAAE,OAAO,CAAC,OAAO,CAAA;IAC5B,aAAa,EAAE,OAAO,CAAC,OAAO,EAAE,CAAA;IAChC,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,kCAAkC,GACvC,GAAG,CAAC,GAAG,CAgDT;AAED,wBAAgB,oCAAoC,CAClD,IAAI,EAAE,0CAA0C,GAC/C,GAAG,CAAC,GAAG,CAQT;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,GAAG,CAAC,GAAG,GAChB,kCAAkC,CASpC;AAED,wBAAgB,oCAAoC,CAClD,QAAQ,EAAE,GAAG,CAAC,GAAG,GAChB,0CAA0C,CAe5C"}

package/dist/hydrate/index.d.ts

@@ -0,0 +1,8 @@
+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

package/dist/hydrate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hydrate/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,SAAS,EACT,eAAe,EACf,eAAe,GAChB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EACL,cAAc,EACd,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,iBAAiB,GACvB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,oCAAoC,EACpC,4BAA4B,EAC5B,oCAAoC,EACpC,4BAA4B,EAC5B,mBAAmB,EACnB,KAAK,kCAAkC,EACvC,KAAK,sCAAsC,EAC3C,KAAK,uCAAuC,EAC5C,KAAK,0CAA0C,EAC/C,KAAK,0CAA0C,EAC/C,KAAK,kCAAkC,EACvC,KAAK,0CAA0C,GAChD,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,oBAAoB,EACpB,6BAA6B,EAC7B,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAA"}

package/dist/hydrate/index.js

@@ -0,0 +1,14 @@
+import { a, c as d, d as t, i as r, l as c, n as l, o, r as s, s as y, t as u, u as H } from "../hydrate-BsQ8nPlI.js";
+export {
+  t as HYDRATE_PROXY_ADDRESS,
+  d as HydrateBuilder,
+  c as HydrateSelector,
+  H as HydrateSource,
+  u as createHydratePayload,
+  s as decodeHydrateExecuteAndSweepCalldata,
+  r as decodeHydrateExecuteCalldata,
+  a as encodeHydrateExecuteAndSweepCalldata,
+  o as encodeHydrateExecuteCalldata,
+  l as encodeMulticallHydrateExecute,
+  y as hydrateFunctionsAbi
+};

package/dist/hydrate/multicall.d.ts

@@ -0,0 +1,69 @@
+import { Address, Bytes, Hex } from 'ox';
+import { Call, HydrateTypeData } from '../actions/types.js';
+export type { HydrateTypeData };
+/**
+ * Encode a single call's hydration entries into the HydrateProxy byte stream.
+ *
+ * This is the low-level per-section encoder: `[callIndex][commands…][0x00]`.
+ * Concatenate multiple results to build a full hydrate payload spanning
+ * several packed calls.
+ */
+export declare function createHydratePayload(callIndex: number, datas: HydrateTypeData[]): Bytes.Bytes;
+/**
+ * Encode multiple destination calls into a single `hydrateExecuteAndSweep`
+ * calldata. Uses Sequence v3 `CallsPayload` natively.
+ *
+ * Three sources of hydration are supported, applied in order per call:
+ *
+ * 1. **Amount placeholder** — calldata containing `TRAILS_HYDRATE_PLACEHOLDER_AMOUNT`
+ *    gets an `erc20Balance / self` hydration entry on the slot. A fresh
+ *    `approve(call.to, sentinel)` is auto-prepended so the downstream contract
+ *    can pull the runtime balance, UNLESS either of the following holds — in
+ *    which case auto-prepending would produce a duplicate / nonsense approve:
+ *
+ *      a) The call itself is `ERC20.approve(spender, sentinel)` — the caller
+ *         is already emitting the approve we would otherwise synthesize.
+ *         We hydrate the caller-provided approve in place.
+ *      b) A dynamic approve of `hydrateToken` to `call.to` was already
+ *         emitted earlier in this batch — either by the caller or by the
+ *         encoder itself. A second auto-prepended approve would be redundant.
+ *
+ *    The ERC-20 whose runtime balance is pulled in is resolved strictly, in
+ *    this order:
+ *      - `call.dynamicAmountToken` if the caller set it.
+ *      - `call.to` iff the call itself is an ERC-20 `approve(...)` (the
+ *        target IS the token contract).
+ *      - Otherwise → **throw**. Custom calls with a `dynamic()` amount must
+ *        carry an explicit `dynamicAmountToken`; there is no implicit fallback
+ *        to the batch-level sweep token because that silently hydrates the
+ *        wrong ERC-20 whenever the input token ≠ destination token.
+ *
+ * 2. **Address placeholder** — calldata containing `TRAILS_HYDRATE_SELF_ADDRESS`
+ *    gets an `address / self` hydration entry for each occurrence. The sentinel
+ *    is zeroed in the calldata; HydrateProxy writes `address(this)` at runtime.
+ *
+ * 3. **Explicit entries** — `call.hydrateEntries` are appended after the above.
+ *    Use these for ETH balance injection, ERC-20 allowance, `to`/`value` overrides,
+ *    or any other type supported by HydrateProxy.
+ *
+ * ## Sweep
+ *
+ * After all calls run, TrailsUtils sweeps remaining funds to `sweepTarget`.
+ * The ERC-20 sweep set is the union of every token the batch touched: the
+ * batch-level destination `token`, every resolved `hydrateToken`, every
+ * approve target, every token referenced by an explicit `erc20Balance`
+ * hydrate entry, and every token listed in a call's `sweepTokens` field
+ * (used by integrations like Uniswap to declare `tokenOut`, which the
+ * encoder cannot otherwise see inside the swap's opaque calldata).
+ * Duplicates are dropped.
+ *
+ * `sweepNative` is `true` when either the batch-level destination `token`
+ * is the zero address (user wants ETH back) OR any call declared the zero
+ * address in its `sweepTokens` (e.g. a swap with native `tokenOut`).
+ */
+export declare function encodeMulticallHydrateExecute({ calls, token, sweepTarget, }: {
+    calls: Call[];
+    token: Address.Address;
+    sweepTarget: Address.Address;
+}): Hex.Hex;
+//# sourceMappingURL=multicall.d.ts.map

package/dist/hydrate/multicall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multicall.d.ts","sourceRoot":"","sources":["../../src/hydrate/multicall.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,IAAI,CAAA;AAElD,OAAO,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAYhE,YAAY,EAAE,eAAe,EAAE,CAAA;AAuB/B;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,eAAe,EAAE,GACvB,KAAK,CAAC,KAAK,CASb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,6BAA6B,CAAC,EAC5C,KAAK,EACL,KAAK,EACL,WAAW,GACZ,EAAE;IACD,KAAK,EAAE,IAAI,EAAE,CAAA;IACb,KAAK,EAAE,OAAO,CAAC,OAAO,CAAA;IACtB,WAAW,EAAE,OAAO,CAAC,OAAO,CAAA;CAC7B,GAAG,GAAG,CAAC,GAAG,CAgOV"}

package/dist/hydrate/payload.d.ts

@@ -0,0 +1,38 @@
+import { Address, Bytes } from 'ox';
+import { HydrateDataSource } from './types.js';
+type HydrateTypeAddress = {
+    type: "address";
+    address: HydrateDataSource;
+    calldataOffset: number;
+};
+type HydrateTypeBalance = {
+    type: "balance";
+    calldataOffset: number;
+    address: HydrateDataSource;
+};
+type HydrateTypeERC20Balance = {
+    type: "erc20Balance";
+    token: Address.Address;
+    calldataOffset: number;
+    address: HydrateDataSource;
+};
+type HydrateTypeERC20Allowance = {
+    type: "erc20Allowance";
+    address: HydrateDataSource;
+    token: Address.Address;
+    spender: HydrateDataSource;
+    calldataOffset: number;
+};
+type HydrateTypeTo = {
+    type: "to";
+    address: HydrateDataSource;
+};
+type HydrateTypeValue = {
+    type: "value";
+    address: HydrateDataSource;
+};
+type HydrateTypeData = HydrateTypeAddress | HydrateTypeBalance | HydrateTypeERC20Balance | HydrateTypeERC20Allowance | HydrateTypeTo | HydrateTypeValue;
+/** One hydrate command (no call index prefix, no section terminator). */
+export declare function encodeHydrateDatum(data: HydrateTypeData): Bytes.Bytes;
+export {};
+//# sourceMappingURL=payload.d.ts.map

package/dist/hydrate/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../src/hydrate/payload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,IAAI,CAAA;AAUnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,SAAS,CAAA;IACf,OAAO,EAAE,iBAAiB,CAAA;IAC1B,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,SAAS,CAAA;IACf,cAAc,EAAE,MAAM,CAAA;IACtB,OAAO,EAAE,iBAAiB,CAAA;CAC3B,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,IAAI,EAAE,cAAc,CAAA;IACpB,KAAK,EAAE,OAAO,CAAC,OAAO,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,OAAO,EAAE,iBAAiB,CAAA;CAC3B,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,gBAAgB,CAAA;IACtB,OAAO,EAAE,iBAAiB,CAAA;IAC1B,KAAK,EAAE,OAAO,CAAC,OAAO,CAAA;IACtB,OAAO,EAAE,iBAAiB,CAAA;IAC1B,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,EAAE,iBAAiB,CAAA;CAC3B,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,iBAAiB,CAAA;CAC3B,CAAA;AAED,KAAK,eAAe,GAChB,kBAAkB,GAClB,kBAAkB,GAClB,uBAAuB,GACvB,yBAAyB,GACzB,aAAa,GACb,gBAAgB,CAAA;AAEpB,yEAAyE;AACzE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,KAAK,CAmCrE"}

package/dist/hydrate/selectors.d.ts

@@ -0,0 +1,28 @@
+import { AbiFunction as OxAbiFunctionType } from 'ox/AbiFunction';
+import { CalldataSelector, PayloadSelector } from './types.js';
+declare class PathBuilder {
+    private readonly steps;
+    callData(callIndex: number): this;
+    slice(offset: number, size: number): this;
+    abi(functionAbi: string | OxAbiFunctionType): this;
+    argSlot(arg: number | string): this;
+    argBytesData(arg: number | string): this;
+    encodedCallsPayload(): this;
+    encodedCallData(index: number): this;
+    asSelector(): PayloadSelector;
+}
+export 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 | OxAbiFunctionType, arg: number | string) => CalldataSelector;
+};
+export {};
+//# sourceMappingURL=selectors.d.ts.map

package/dist/hydrate/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../src/hydrate/selectors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,IAAI,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AACtE,OAAO,KAAK,EAEV,gBAAgB,EAEhB,eAAe,EAChB,MAAM,YAAY,CAAA;AA2QnB,cAAM,WAAW;IACf,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IAEvC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAoBjC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAsBzC,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAwBlD,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAuBnC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IA2BxC,mBAAmB,IAAI,IAAI;IAY3B,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IA4BpC,UAAU,IAAI,eAAe;CAG9B;AAED,eAAO,MAAM,eAAe;8BACX,MAAM,QAAQ,MAAM,KAAG,gBAAgB;gCAOrC,MAAM,UAAU,MAAM,QAAQ,MAAM,KAAG,eAAe;yBAsB/D,WAAW;IAGnB;;;;;;OAMG;qCAEY,MAAM,GAAG,iBAAiB,OAClC,MAAM,GAAG,MAAM,KACnB,gBAAgB;CAeX,CAAA"}

package/dist/hydrate/source.d.ts

@@ -0,0 +1,11 @@
+import { HydrateDataSource, RuntimeHydrateDataSource, ExplicitHydrateDataSource } from './types.js';
+/**
+ * Helper constructors for hydrate runtime sources.
+ */
+export declare const HydrateSource: {
+    self(): ExplicitHydrateDataSource;
+    msgSender(): RuntimeHydrateDataSource;
+    txOrigin(): RuntimeHydrateDataSource;
+    address(address: HydrateDataSource): ExplicitHydrateDataSource;
+};
+//# sourceMappingURL=source.d.ts.map

package/dist/hydrate/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/hydrate/source.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,YAAY,CAAA;AAEnB;;GAEG;AACH,eAAO,MAAM,aAAa;YAChB,yBAAyB;iBAIpB,wBAAwB;gBAIzB,wBAAwB;qBAInB,iBAAiB,GAAG,yBAAyB;CAa/D,CAAA"}

package/dist/hydrate/types.d.ts

@@ -0,0 +1,21 @@
+import { Address, Hex } from 'ox';
+export type ExplicitHydrateDataSource = "self" | Address.Address;
+export type RuntimeHydrateDataSource = "msg.sender" | "tx.origin";
+export type HydrateDataSource = ExplicitHydrateDataSource | RuntimeHydrateDataSource;
+export interface CalldataSelector {
+    offset: number;
+    size: number;
+}
+export interface ByteRange {
+    callIndex: number;
+    offset: number;
+    size: number;
+}
+export type HydrateCallLike = {
+    data: Hex.Hex;
+};
+export interface PayloadSelector {
+    resolve(calls: readonly HydrateCallLike[]): ByteRange[];
+    toString(): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/hydrate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/hydrate/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AAEtC,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAA;AAEhE,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,WAAW,CAAA;AAEjE,MAAM,MAAM,iBAAiB,GACzB,yBAAyB,GACzB,wBAAwB,CAAA;AAE5B,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,GAAG,CAAC,GAAG,CAAA;CAAE,CAAA;AAE/C,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EAAE,CAAA;IACvD,QAAQ,IAAI,MAAM,CAAA;CACnB"}

package/dist/hydrate/utils.d.ts

@@ -0,0 +1,8 @@
+import { Bytes } from 'ox';
+import { CalldataSelector, HydrateDataSource } from './types.js';
+export declare function hydrateDataTypeToFlag(type: HydrateDataSource): number;
+/** Ensures `value` fits the hydrate wire calldata offset (uint16, LE in payload). */
+export declare function assertU16(value: number): void;
+export declare function toU16Bytes(value: number): Bytes.Bytes;
+export declare function selectorEndOffset(selector: CalldataSelector): number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/hydrate/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/hydrate/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,EAAE,MAAM,IAAI,CAAA;AAOnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAErE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAMrE;AAED,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAI7C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC,KAAK,CAGrD;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAEpE"}