0xtrails 0.13.2 → 0.14.0

package/dist/hydrate-Cr9eaeDK.js

@@ -0,0 +1,654 @@
+import { Payload as H } from "@0xsequence/wallet-primitives";
+import { AbiFunction as d, Address as w, Bytes as i, Hex as u } from "ox";
+function b(t) {
+  "@babel/helpers - typeof";
+  return b = 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;
+  }, b(t);
+}
+function W(t, e) {
+  if (b(t) != "object" || !t) return t;
+  var r = t[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var n = r.call(t, e || "default");
+    if (b(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(t);
+}
+function L(t) {
+  var e = W(t, "string");
+  return b(e) == "symbol" ? e : e + "";
+}
+function S(t, e, r) {
+  return (e = L(e)) in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+var re = w.from("0x000000004f702C8398e158108937814d074cD74b");
+function O(t) {
+  if (typeof t == "string") {
+    const e = d.from(t);
+    if (e.type !== "function") throw new Error("Expected function ABI signature");
+    return e;
+  }
+  return t;
+}
+function A(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 Y(t, e) {
+  const r = t[e]?.type;
+  if (!r) throw new Error(`Input at index ${e} has no ABI type`);
+  return r;
+}
+function N(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 _(t) {
+  const e = t.match(/^(.*)\[(\d+)?\]$/);
+  return e ? [e[2] ? Number(e[2]) : null, e[1]] : void 0;
+}
+function v(t) {
+  const { type: e } = t;
+  if (e === "string" || e === "bytes" || e.endsWith("[]")) return !0;
+  if (e === "tuple") return t.components?.some(v) ?? !1;
+  const r = _(e);
+  return !!(r && v({
+    ...t,
+    type: r[1]
+  }));
+}
+function E(t) {
+  if (v(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 += E(o);
+    return n;
+  }
+  const e = _(t.type);
+  if (e) {
+    const [r, n] = e, o = E({
+      ...t,
+      type: n
+    });
+    return r === null ? 1 : o * r;
+  }
+  return 1;
+}
+function F(t, e) {
+  const r = t.inputs, n = r[e];
+  if (!n) throw new Error(`Argument index ${e} out of bounds`);
+  if (v(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 += E(l);
+  }
+  const s = E(n);
+  return {
+    start: 4 + o * 32,
+    length: s * 32
+  };
+}
+function q(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 m = 0; m < r; m++) {
+    const g = n[m];
+    if (!g) throw new Error("Unexpected missing ABI input");
+    s += E(g);
+  }
+  const a = 4 + s * 32;
+  if (a + 32 > t.length) throw new Error("Calldata too short");
+  const l = Number(N(t, a));
+  if (!Number.isInteger(l) || l < 0) throw new Error(`Invalid dynamic offset: ${l}`);
+  const f = 4 + l;
+  if (f + 32 > t.length) throw new Error("Calldata too short for tail");
+  const c = Number(N(t, f));
+  if (!Number.isInteger(c) || c < 0) throw new Error(`Invalid dynamic data length: ${c}`);
+  const $ = f + 32;
+  if ($ + c > t.length) throw new Error("Dynamic bytes data out of bounds");
+  return {
+    start: $,
+    length: c
+  };
+}
+function X(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 C(t, e) {
+  const r = t[e.callIndex]?.data;
+  if (!r || !u.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 K = 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(" -> ")})`;
+  }
+}, M = class {
+  constructor() {
+    S(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 || !u.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 = O(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 = d.getSelector(e);
+        for (const s of n.ranges) {
+          const a = C(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 = A(n, t), { start: s, length: a } = F(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 = A(n, t);
+        return { ranges: r.ranges.map((s) => {
+          const { start: a, length: l } = q(C(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 = X(C(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 K([...this.steps]);
+  }
+}, V = {
+  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 || !u.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 M();
+  },
+  argument(t, e) {
+    const r = O(t), n = r.inputs, o = A(n, e), s = n[o];
+    if (!s) throw new Error(`Argument index ${o} out of bounds`);
+    if (v(s)) {
+      const f = Y(n, o);
+      throw new Error(`Argument '${String(e)}' has dynamic type '${f}'. Use HydrateSelector.offset(...) or path-based selectors.`);
+    }
+    const { start: a, length: l } = F(r, o);
+    return {
+      offset: a,
+      size: l
+    };
+  }
+};
+function D(t) {
+  if (t === "self") return 0;
+  if (t === "msg.sender") return 1;
+  if (t === "tx.origin") return 2;
+  if (w.validate(t)) return 3;
+  throw new Error("Invalid hydrate data source");
+}
+function j(t) {
+  if (!Number.isInteger(t) || t < 0 || t > 65535) throw new Error(`Calldata offset out of uint16 range: ${t}`);
+}
+function G(t) {
+  return j(t), i.fromNumber(t, { size: 2 });
+}
+function T(t) {
+  return t.offset + t.size;
+}
+function y(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 |= D(t.address);
+  const r = [i.fromNumber(e, { size: 1 })];
+  if (w.validate(t.address) && r.push(i.fromHex(t.address)), t.type === "address" || t.type === "balance" || t.type === "erc20Balance" || t.type === "erc20Allowance") {
+    if (r.push(G(t.calldataOffset)), t.type === "erc20Balance") r.push(i.fromHex(t.token));
+    else if (t.type === "erc20Allowance") {
+      r.push(i.fromHex(t.token));
+      const n = D(t.spender);
+      r.push(i.fromNumber(n, { size: 1 })), w.validate(t.spender) && r.push(i.fromHex(t.spender));
+    }
+  }
+  return i.concat(...r);
+}
+function U(t) {
+  return !Array.isArray(t);
+}
+function J(t) {
+  if (typeof t == "string") {
+    const e = d.from(t);
+    if (e.type !== "function") throw new Error("Expected function ABI signature");
+    return e;
+  }
+  return t;
+}
+function Q(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 Z(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 ne = class R {
+  constructor(e) {
+    S(this, "calls", void 0), S(this, "byCall", /* @__PURE__ */ new Map()), this.calls = Array.isArray(e) ? e : e.calls.map((r) => ({ data: r.data ?? "0x" }));
+  }
+  static from(e) {
+    return new R(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, y({
+          type: "address",
+          address: o,
+          calldataOffset: a
+        }));
+        break;
+      }
+      case "balance": {
+        const { selector: n, address: o } = e, s = this.resolveUint256Selector(r, n);
+        this.appendCommand(r, y({
+          type: "balance",
+          address: o,
+          calldataOffset: s.offset
+        }));
+        break;
+      }
+      case "erc20Balance": {
+        const { selector: n, token: o, address: s } = e, a = this.resolveUint256Selector(r, n);
+        w.assert(o), this.appendCommand(r, y({
+          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);
+        w.assert(s), this.appendCommand(r, y({
+          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 (U(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, f = s !== void 0;
+    if (!a && !l && !f) throw new Error("hydrateCall() requires at least one of data, to, or value");
+    if (this.assertCallIndex(r), n !== void 0) if (U(n)) {
+      const { function: c, args: $ } = n, m = Object.entries($), g = J(c), P = g.inputs, k = m.map(([h, p]) => {
+        const B = Q(P, h), z = P[B];
+        if (!z) throw new Error(`Argument index ${B} out of bounds`);
+        return Z(h, z, p), {
+          spec: p,
+          selector: V.argument(g, h)
+        };
+      });
+      k.sort((h, p) => h.selector.offset - p.selector.offset);
+      for (const { spec: h, selector: p } of k) this.data({
+        ...h,
+        callIndex: r,
+        selector: p
+      });
+    } else
+      for (const c of n) this.data({
+        ...c,
+        callIndex: r
+      });
+    return l && this.to({
+      callIndex: r,
+      address: o
+    }), f && this.value({
+      callIndex: r,
+      address: s
+    }), this;
+  }
+  to(e) {
+    const { callIndex: r, address: n } = e;
+    return this.assertCallIndex(r), this.appendCommand(r, y({
+      type: "to",
+      address: n
+    })), this;
+  }
+  value(e) {
+    const { callIndex: r, address: n } = e;
+    return this.assertCallIndex(r), this.appendCommand(r, y({
+      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 || !u.validate(n)) throw new Error(`Invalid calldata at call index ${e}`);
+    const o = i.fromHex(n).length;
+    if (T(r) > o) throw new Error(`Selector out of bounds for call ${e}: need ${T(r)} bytes, got ${o}`);
+    j(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);
+  }
+}, I = d.from("function hydrateExecute(bytes packedPayload, bytes hydratePayload) payable"), x = d.from("function hydrateExecuteAndSweep(bytes packedPayload, bytes hydratePayload, address sweepTarget, address[] tokensToSweep, bool sweepNative) payable"), oe = [I, x];
+function se(t) {
+  let e;
+  if ("packedPayload" in t) e = u.from(t.packedPayload);
+  else if ("target" in t) e = i.toHex(H.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(H.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 d.encodeData(I, [e, u.from(t.hydratePayload)]);
+}
+function ae(t) {
+  return d.encodeData(x, [
+    u.from(t.packedPayload),
+    u.from(t.hydratePayload),
+    t.sweepTarget,
+    t.tokensToSweep,
+    t.sweepNative
+  ]);
+}
+function ie(t) {
+  const [e, r] = d.decodeData(I, t);
+  return {
+    packedPayload: e,
+    hydratePayload: r
+  };
+}
+function le(t) {
+  const [e, r, n, o, s] = d.decodeData(x, t);
+  return {
+    packedPayload: e,
+    hydratePayload: r,
+    sweepTarget: n,
+    tokensToSweep: o,
+    sweepNative: s
+  };
+}
+export {
+  oe as a,
+  re as c,
+  se as i,
+  S as l,
+  ie as n,
+  ne as o,
+  ae as r,
+  V as s,
+  le as t
+};