@coinbase/cdp-hooks 0.0.91 → 0.0.92

package/dist/esm/index311.js

@@ -1,4 +1,22 @@
-var e = { exports: {} };
+const o = /* @__PURE__ */ BigInt(4294967295), i = /* @__PURE__ */ BigInt(32);
+function s(t, r = !1) {
+  return r ? { h: Number(t & o), l: Number(t >> i & o) } : { h: Number(t >> i & o) | 0, l: Number(t & o) | 0 };
+}
+function h(t, r = !1) {
+  const n = t.length;
+  let l = new Uint32Array(n), c = new Uint32Array(n);
+  for (let e = 0; e < n; e++) {
+    const { h: u, l: f } = s(t[e], r);
+    [l[e], c[e]] = [u, f];
+  }
+  return [l, c];
+}
+const m = (t, r, n) => t << n | r >>> 32 - n, A = (t, r, n) => r << n | t >>> 32 - n, B = (t, r, n) => r << n - 32 | t >>> 64 - n, a = (t, r, n) => t << n - 32 | r >>> 64 - n;
 export {
-  e as __module
+  s as fromBig,
+  B as rotlBH,
+  a as rotlBL,
+  m as rotlSH,
+  A as rotlSL,
+  h as split
 };

package/dist/esm/index312.js

@@ -1,72 +1,148 @@
-import { __module as a } from "./index329.js";
-var h;
-function c() {
-  return h ? a.exports : (h = 1, function() {
-    var f = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", u = {
-      // Bit-wise rotation left
-      rotl: function(r, t) {
-        return r << t | r >>> 32 - t;
-      },
-      // Bit-wise rotation right
-      rotr: function(r, t) {
-        return r << 32 - t | r >>> t;
-      },
-      // Swap big-endian to little-endian and vice versa
-      endian: function(r) {
-        if (r.constructor == Number)
-          return u.rotl(r, 8) & 16711935 | u.rotl(r, 24) & 4278255360;
-        for (var t = 0; t < r.length; t++)
-          r[t] = u.endian(r[t]);
-        return r;
-      },
-      // Generate an array of any length of random bytes
-      randomBytes: function(r) {
-        for (var t = []; r > 0; r--)
-          t.push(Math.floor(Math.random() * 256));
-        return t;
-      },
-      // Convert a byte array to big-endian 32-bit words
-      bytesToWords: function(r) {
-        for (var t = [], n = 0, o = 0; n < r.length; n++, o += 8)
-          t[o >>> 5] |= r[n] << 24 - o % 32;
-        return t;
-      },
-      // Convert big-endian 32-bit words to a byte array
-      wordsToBytes: function(r) {
-        for (var t = [], n = 0; n < r.length * 32; n += 8)
-          t.push(r[n >>> 5] >>> 24 - n % 32 & 255);
-        return t;
-      },
-      // Convert a byte array to a hex string
-      bytesToHex: function(r) {
-        for (var t = [], n = 0; n < r.length; n++)
-          t.push((r[n] >>> 4).toString(16)), t.push((r[n] & 15).toString(16));
-        return t.join("");
-      },
-      // Convert a hex string to a byte array
-      hexToBytes: function(r) {
-        for (var t = [], n = 0; n < r.length; n += 2)
-          t.push(parseInt(r.substr(n, 2), 16));
-        return t;
-      },
-      // Convert a byte array to a base-64 string
-      bytesToBase64: function(r) {
-        for (var t = [], n = 0; n < r.length; n += 3)
-          for (var o = r[n] << 16 | r[n + 1] << 8 | r[n + 2], e = 0; e < 4; e++)
-            n * 8 + e * 6 <= r.length * 8 ? t.push(f.charAt(o >>> 6 * (3 - e) & 63)) : t.push("=");
-        return t.join("");
-      },
-      // Convert a base-64 string to a byte array
-      base64ToBytes: function(r) {
-        r = r.replace(/[^A-Z0-9+\/]/ig, "");
-        for (var t = [], n = 0, o = 0; n < r.length; o = ++n % 4)
-          o != 0 && t.push((f.indexOf(r.charAt(n - 1)) & Math.pow(2, -2 * o + 8) - 1) << o * 2 | f.indexOf(r.charAt(n)) >>> 6 - o * 2);
-        return t;
-      }
-    };
-    a.exports = u;
-  }(), a.exports);
+import { crypto as u } from "./index325.js";
+function w(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function l(t) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new Error("positive integer expected, got " + t);
+}
+function c(t, ...e) {
+  if (!w(t))
+    throw new Error("Uint8Array expected");
+  if (e.length > 0 && !e.includes(t.length))
+    throw new Error("Uint8Array expected of length " + e + ", got length=" + t.length);
+}
+function U(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  l(t.outputLen), l(t.blockLen);
+}
+function B(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function H(t, e) {
+  c(t);
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new Error("digestInto() expects output buffer of length at least " + n);
+}
+function L(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function V(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function _(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function S(t, e) {
+  return t << 32 - e | t >>> e;
+}
+const d = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function h(t) {
+  return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
+}
+function x(t) {
+  for (let e = 0; e < t.length; e++)
+    t[e] = h(t[e]);
+  return t;
+}
+const T = d ? (t) => t : x, p = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", A = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function k(t) {
+  if (c(t), p)
+    return t.toHex();
+  let e = "";
+  for (let n = 0; n < t.length; n++)
+    e += A[t[n]];
+  return e;
+}
+const f = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function y(t) {
+  if (t >= f._0 && t <= f._9)
+    return t - f._0;
+  if (t >= f.A && t <= f.F)
+    return t - (f.A - 10);
+  if (t >= f.a && t <= f.f)
+    return t - (f.a - 10);
+}
+function I(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  if (p)
+    return Uint8Array.fromHex(t);
+  const e = t.length, n = e / 2;
+  if (e % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + e);
+  const r = new Uint8Array(n);
+  for (let o = 0, i = 0; o < n; o++, i += 2) {
+    const s = y(t.charCodeAt(i)), a = y(t.charCodeAt(i + 1));
+    if (s === void 0 || a === void 0) {
+      const g = t[i] + t[i + 1];
+      throw new Error('hex string expected, got non-hex character "' + g + '" at index ' + i);
+    }
+    r[o] = s * 16 + a;
+  }
+  return r;
+}
+function m(t) {
+  if (typeof t != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function b(t) {
+  return typeof t == "string" && (t = m(t)), c(t), t;
+}
+function R(...t) {
+  let e = 0;
+  for (let r = 0; r < t.length; r++) {
+    const o = t[r];
+    c(o), e += o.length;
+  }
+  const n = new Uint8Array(e);
+  for (let r = 0, o = 0; r < t.length; r++) {
+    const i = t[r];
+    n.set(i, o), o += i.length;
+  }
+  return n;
+}
+class F {
+}
+function O(t) {
+  const e = (r) => t().update(b(r)).digest(), n = t();
+  return e.outputLen = n.outputLen, e.blockLen = n.blockLen, e.create = () => t(), e;
+}
+function v(t = 32) {
+  if (u && typeof u.getRandomValues == "function")
+    return u.getRandomValues(new Uint8Array(t));
+  if (u && typeof u.randomBytes == "function")
+    return Uint8Array.from(u.randomBytes(t));
+  throw new Error("crypto.getRandomValues must be defined");
 }
 export {
-  c as __require
+  F as Hash,
+  c as abytes,
+  B as aexists,
+  U as ahash,
+  l as anumber,
+  H as aoutput,
+  h as byteSwap,
+  x as byteSwap32,
+  k as bytesToHex,
+  V as clean,
+  R as concatBytes,
+  O as createHasher,
+  _ as createView,
+  I as hexToBytes,
+  w as isBytes,
+  d as isLE,
+  v as randomBytes,
+  S as rotr,
+  T as swap32IfBE,
+  b as toBytes,
+  L as u32,
+  m as utf8ToBytes
 };

package/dist/esm/index313.js

@@ -1,37 +1,15 @@
-var o, u;
-function c() {
-  if (u) return o;
-  u = 1;
-  var t = {
-    // UTF-8 encoding
-    utf8: {
-      // Convert a string to a byte array
-      stringToBytes: function(n) {
-        return t.bin.stringToBytes(unescape(encodeURIComponent(n)));
-      },
-      // Convert a byte array to a string
-      bytesToString: function(n) {
-        return decodeURIComponent(escape(t.bin.bytesToString(n)));
-      }
-    },
-    // Binary encoding
-    bin: {
-      // Convert a string to a byte array
-      stringToBytes: function(n) {
-        for (var e = [], r = 0; r < n.length; r++)
-          e.push(n.charCodeAt(r) & 255);
-        return e;
-      },
-      // Convert a byte array to a string
-      bytesToString: function(n) {
-        for (var e = [], r = 0; r < n.length; r++)
-          e.push(String.fromCharCode(n[r]));
-        return e.join("");
-      }
-    }
-  };
-  return o = t, o;
-}
+const s = {
+  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+  l1Block: { address: "0x4200000000000000000000000000000000000015" },
+  l2CrossDomainMessenger: {
+    address: "0x4200000000000000000000000000000000000007"
+  },
+  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+  l2ToL1MessagePasser: {
+    address: "0x4200000000000000000000000000000000000016"
+  }
+};
 export {
-  c as __require
+  s as contracts
 };

package/dist/esm/index314.js

@@ -1,17 +1,38 @@
-var f, e;
-function t() {
-  if (e) return f;
-  e = 1, f = function(r) {
-    return r != null && (u(r) || n(r) || !!r._isBuffer);
-  };
-  function u(r) {
-    return !!r.constructor && typeof r.constructor.isBuffer == "function" && r.constructor.isBuffer(r);
-  }
-  function n(r) {
-    return typeof r.readFloatLE == "function" && typeof r.slice == "function" && u(r.slice(0, 0));
-  }
-  return f;
-}
+import { hexToBigInt as n } from "./index209.js";
+import { defineBlock as r } from "./index181.js";
+import { defineTransaction as s, formatTransaction as m } from "./index183.js";
+import { defineTransactionReceipt as l } from "./index210.js";
+const p = {
+  block: /* @__PURE__ */ r({
+    format(e) {
+      return {
+        transactions: e.transactions?.map((t) => {
+          if (typeof t == "string")
+            return t;
+          const i = m(t);
+          return i.typeHex === "0x7e" && (i.isSystemTx = t.isSystemTx, i.mint = t.mint ? n(t.mint) : void 0, i.sourceHash = t.sourceHash, i.type = "deposit"), i;
+        }),
+        stateRoot: e.stateRoot
+      };
+    }
+  }),
+  transaction: /* @__PURE__ */ s({
+    format(e) {
+      const o = {};
+      return e.type === "0x7e" && (o.isSystemTx = e.isSystemTx, o.mint = e.mint ? n(e.mint) : void 0, o.sourceHash = e.sourceHash, o.type = "deposit"), o;
+    }
+  }),
+  transactionReceipt: /* @__PURE__ */ l({
+    format(e) {
+      return {
+        l1GasPrice: e.l1GasPrice ? n(e.l1GasPrice) : null,
+        l1GasUsed: e.l1GasUsed ? n(e.l1GasUsed) : null,
+        l1Fee: e.l1Fee ? n(e.l1Fee) : null,
+        l1FeeScalar: e.l1FeeScalar ? Number(e.l1FeeScalar) : null
+      };
+    }
+  })
+};
 export {
-  t as __require
+  p as formatters
 };

package/dist/esm/index315.js

@@ -1,71 +1,44 @@
-function d(n, y, i) {
-  let a = "";
-  if (i)
-    for (const e of Object.entries(i)) {
-      if (!e)
-        continue;
-      let s = "";
-      for (const t of e[1])
-        s += `[${t.type}${t.name ? `:${t.name}` : ""}]`;
-      a += `(${e[0]}{${s}})`;
-    }
-  return y ? `${y}:${n}${a}` : n;
+import { InvalidAddressError as a } from "./index171.js";
+import { isAddress as f } from "./index198.js";
+import { concatHex as p } from "./index180.js";
+import { toHex as i } from "./index176.js";
+import { toRlp as x } from "./index221.js";
+import { serializeTransaction as l } from "./index254.js";
+function T(r, e) {
+  return h(r) ? z(r) : l(r, e);
+}
+const E = {
+  transaction: T
+};
+function z(r) {
+  w(r);
+  const { sourceHash: e, data: o, from: m, gas: t, isSystemTx: u, mint: s, to: c, value: n } = r, d = [
+    e,
+    m,
+    c ?? "0x",
+    s ? i(s) : "0x",
+    n ? i(n) : "0x",
+    t ? i(t) : "0x",
+    u ? "0x1" : "0x",
+    o ?? "0x"
+  ];
+  return p([
+    "0x7e",
+    x(d)
+  ]);
+}
+function h(r) {
+  return r.type === "deposit" || typeof r.sourceHash < "u";
+}
+function w(r) {
+  const { from: e, to: o } = r;
+  if (e && !f(e))
+    throw new a({ address: e });
+  if (o && !f(o))
+    throw new a({ address: o });
 }
-const p = /* @__PURE__ */ new Map([
-  // Unnamed
-  ["address", { type: "address" }],
-  ["bool", { type: "bool" }],
-  ["bytes", { type: "bytes" }],
-  ["bytes32", { type: "bytes32" }],
-  ["int", { type: "int256" }],
-  ["int256", { type: "int256" }],
-  ["string", { type: "string" }],
-  ["uint", { type: "uint256" }],
-  ["uint8", { type: "uint8" }],
-  ["uint16", { type: "uint16" }],
-  ["uint24", { type: "uint24" }],
-  ["uint32", { type: "uint32" }],
-  ["uint64", { type: "uint64" }],
-  ["uint96", { type: "uint96" }],
-  ["uint112", { type: "uint112" }],
-  ["uint160", { type: "uint160" }],
-  ["uint192", { type: "uint192" }],
-  ["uint256", { type: "uint256" }],
-  // Named
-  ["address owner", { type: "address", name: "owner" }],
-  ["address to", { type: "address", name: "to" }],
-  ["bool approved", { type: "bool", name: "approved" }],
-  ["bytes _data", { type: "bytes", name: "_data" }],
-  ["bytes data", { type: "bytes", name: "data" }],
-  ["bytes signature", { type: "bytes", name: "signature" }],
-  ["bytes32 hash", { type: "bytes32", name: "hash" }],
-  ["bytes32 r", { type: "bytes32", name: "r" }],
-  ["bytes32 root", { type: "bytes32", name: "root" }],
-  ["bytes32 s", { type: "bytes32", name: "s" }],
-  ["string name", { type: "string", name: "name" }],
-  ["string symbol", { type: "string", name: "symbol" }],
-  ["string tokenURI", { type: "string", name: "tokenURI" }],
-  ["uint tokenId", { type: "uint256", name: "tokenId" }],
-  ["uint8 v", { type: "uint8", name: "v" }],
-  ["uint256 balance", { type: "uint256", name: "balance" }],
-  ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
-  ["uint256 value", { type: "uint256", name: "value" }],
-  // Indexed
-  [
-    "event:address indexed from",
-    { type: "address", name: "from", indexed: !0 }
-  ],
-  ["event:address indexed to", { type: "address", name: "to", indexed: !0 }],
-  [
-    "event:uint indexed tokenId",
-    { type: "uint256", name: "tokenId", indexed: !0 }
-  ],
-  [
-    "event:uint256 indexed tokenId",
-    { type: "uint256", name: "tokenId", indexed: !0 }
-  ]
-]);
 export {
-  d as getParameterCacheKey,
-  p as parameterCache
+  w as assertTransactionDeposit,
+  T as serializeTransaction,
+  E as serializers
 };

package/dist/esm/index316.js

@@ -1,6 +1,71 @@
-function n(e) {
-  return `[${e.slice(2)}]`;
+function d(n, y, i) {
+  let a = "";
+  if (i)
+    for (const e of Object.entries(i)) {
+      if (!e)
+        continue;
+      let s = "";
+      for (const t of e[1])
+        s += `[${t.type}${t.name ? `:${t.name}` : ""}]`;
+      a += `(${e[0]}{${s}})`;
+    }
+  return y ? `${y}:${n}${a}` : n;
 }
+const p = /* @__PURE__ */ new Map([
+  // Unnamed
+  ["address", { type: "address" }],
+  ["bool", { type: "bool" }],
+  ["bytes", { type: "bytes" }],
+  ["bytes32", { type: "bytes32" }],
+  ["int", { type: "int256" }],
+  ["int256", { type: "int256" }],
+  ["string", { type: "string" }],
+  ["uint", { type: "uint256" }],
+  ["uint8", { type: "uint8" }],
+  ["uint16", { type: "uint16" }],
+  ["uint24", { type: "uint24" }],
+  ["uint32", { type: "uint32" }],
+  ["uint64", { type: "uint64" }],
+  ["uint96", { type: "uint96" }],
+  ["uint112", { type: "uint112" }],
+  ["uint160", { type: "uint160" }],
+  ["uint192", { type: "uint192" }],
+  ["uint256", { type: "uint256" }],
+  // Named
+  ["address owner", { type: "address", name: "owner" }],
+  ["address to", { type: "address", name: "to" }],
+  ["bool approved", { type: "bool", name: "approved" }],
+  ["bytes _data", { type: "bytes", name: "_data" }],
+  ["bytes data", { type: "bytes", name: "data" }],
+  ["bytes signature", { type: "bytes", name: "signature" }],
+  ["bytes32 hash", { type: "bytes32", name: "hash" }],
+  ["bytes32 r", { type: "bytes32", name: "r" }],
+  ["bytes32 root", { type: "bytes32", name: "root" }],
+  ["bytes32 s", { type: "bytes32", name: "s" }],
+  ["string name", { type: "string", name: "name" }],
+  ["string symbol", { type: "string", name: "symbol" }],
+  ["string tokenURI", { type: "string", name: "tokenURI" }],
+  ["uint tokenId", { type: "uint256", name: "tokenId" }],
+  ["uint8 v", { type: "uint8", name: "v" }],
+  ["uint256 balance", { type: "uint256", name: "balance" }],
+  ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
+  ["uint256 value", { type: "uint256", name: "value" }],
+  // Indexed
+  [
+    "event:address indexed from",
+    { type: "address", name: "from", indexed: !0 }
+  ],
+  ["event:address indexed to", { type: "address", name: "to", indexed: !0 }],
+  [
+    "event:uint indexed tokenId",
+    { type: "uint256", name: "tokenId", indexed: !0 }
+  ],
+  [
+    "event:uint256 indexed tokenId",
+    { type: "uint256", name: "tokenId", indexed: !0 }
+  ]
+]);
 export {
-  n as encodeLabelhash
+  d as getParameterCacheKey,
+  p as parameterCache
 };