0xtrails 0.13.2 → 0.15.0

package/dist/hydrate-BsQ8nPlI.js

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