@coinbase/cdp-core 0.0.48 → 0.0.50

package/dist/native/index.native109.js

@@ -1,120 +1,82 @@
-import { isJWK as p } from "./index.native120.js";
-import { decode as m } from "./index.native104.js";
-import y from "./index.native121.js";
-import { isCryptoKey as S, isKeyObject as K } from "./index.native119.js";
-let c;
-const f = async (e, r, s, i = !1) => {
-  c ||= /* @__PURE__ */ new WeakMap();
-  let n = c.get(e);
-  if (n?.[s])
-    return n[s];
-  const t = await y({ ...r, alg: s });
-  return i && Object.freeze(e), n ? n[s] = t : c.set(e, { [s]: t }), t;
-}, E = (e, r) => {
-  c ||= /* @__PURE__ */ new WeakMap();
-  let s = c.get(e);
-  if (s?.[r])
-    return s[r];
-  const i = e.type === "public", n = !!i;
-  let t;
-  if (e.asymmetricKeyType === "x25519") {
-    switch (r) {
-      case "ECDH-ES":
-      case "ECDH-ES+A128KW":
-      case "ECDH-ES+A192KW":
-      case "ECDH-ES+A256KW":
-        break;
-      default:
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    }
-    t = e.toCryptoKey(e.asymmetricKeyType, n, i ? [] : ["deriveBits"]);
-  }
-  if (e.asymmetricKeyType === "ed25519") {
-    if (r !== "EdDSA" && r !== "Ed25519")
-      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    t = e.toCryptoKey(e.asymmetricKeyType, n, [
-      i ? "verify" : "sign"
-    ]);
-  }
-  if (e.asymmetricKeyType === "rsa") {
-    let a;
-    switch (r) {
-      case "RSA-OAEP":
-        a = "SHA-1";
-        break;
-      case "RS256":
-      case "PS256":
-      case "RSA-OAEP-256":
-        a = "SHA-256";
-        break;
-      case "RS384":
-      case "PS384":
-      case "RSA-OAEP-384":
-        a = "SHA-384";
-        break;
-      case "RS512":
-      case "PS512":
-      case "RSA-OAEP-512":
-        a = "SHA-512";
-        break;
-      default:
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    }
-    if (r.startsWith("RSA-OAEP"))
-      return e.toCryptoKey({
-        name: "RSA-OAEP",
-        hash: a
-      }, n, i ? ["encrypt"] : ["decrypt"]);
-    t = e.toCryptoKey({
-      name: r.startsWith("PS") ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
-      hash: a
-    }, n, [i ? "verify" : "sign"]);
-  }
-  if (e.asymmetricKeyType === "ec") {
-    const o = (/* @__PURE__ */ new Map([
-      ["prime256v1", "P-256"],
-      ["secp384r1", "P-384"],
-      ["secp521r1", "P-521"]
-    ])).get(e.asymmetricKeyDetails?.namedCurve);
-    if (!o)
-      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    r === "ES256" && o === "P-256" && (t = e.toCryptoKey({
-      name: "ECDSA",
-      namedCurve: o
-    }, n, [i ? "verify" : "sign"])), r === "ES384" && o === "P-384" && (t = e.toCryptoKey({
-      name: "ECDSA",
-      namedCurve: o
-    }, n, [i ? "verify" : "sign"])), r === "ES512" && o === "P-521" && (t = e.toCryptoKey({
-      name: "ECDSA",
-      namedCurve: o
-    }, n, [i ? "verify" : "sign"])), r.startsWith("ECDH-ES") && (t = e.toCryptoKey({
-      name: "ECDH",
-      namedCurve: o
-    }, n, i ? [] : ["deriveBits"]));
-  }
-  if (!t)
-    throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-  return s ? s[r] = t : c.set(e, { [r]: t }), t;
-}, d = async (e, r) => {
-  if (e instanceof Uint8Array || S(e))
-    return e;
-  if (K(e)) {
-    if (e.type === "secret")
-      return e.export();
-    if ("toCryptoKey" in e && typeof e.toCryptoKey == "function")
-      try {
-        return E(e, r);
-      } catch (i) {
-        if (i instanceof TypeError)
-          throw i;
-      }
-    let s = e.export({ format: "jwk" });
-    return f(e, s, r);
-  }
-  if (p(e))
-    return e.k ? m(e.k) : f(e, e, r, !0);
-  throw new Error("unreachable");
-};
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function o(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function w(e) {
+  if (!Number.isSafeInteger(e) || e < 0)
+    throw new Error("positive integer expected, got " + e);
+}
+function r(e, ...t) {
+  if (!o(e))
+    throw new Error("Uint8Array expected");
+  if (t.length > 0 && !t.includes(e.length))
+    throw new Error("Uint8Array expected of length " + t + ", got length=" + e.length);
+}
+function h(e, t = !0) {
+  if (e.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (t && e.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function l(e, t) {
+  r(e);
+  const n = t.outputLen;
+  if (e.length < n)
+    throw new Error("digestInto() expects output buffer of length at least " + n);
+}
+function a(e) {
+  return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+}
+function g(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+function p(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function b(e, t) {
+  return e << 32 - t | e >>> t;
+}
+const i = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function u(e) {
+  return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
+}
+function c(e) {
+  for (let t = 0; t < e.length; t++)
+    e[t] = u(e[t]);
+  return e;
+}
+const x = i ? (e) => e : c;
+function s(e) {
+  if (typeof e != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function y(e) {
+  return typeof e == "string" && (e = s(e)), r(e), e;
+}
+class d {
+}
+function E(e) {
+  const t = (f) => e().update(y(f)).digest(), n = e();
+  return t.outputLen = n.outputLen, t.blockLen = n.blockLen, t.create = () => e(), t;
+}
 export {
-  d as default
+  d as Hash,
+  r as abytes,
+  h as aexists,
+  w as anumber,
+  l as aoutput,
+  u as byteSwap,
+  c as byteSwap32,
+  g as clean,
+  E as createHasher,
+  p as createView,
+  o as isBytes,
+  i as isLE,
+  b as rotr,
+  x as swap32IfBE,
+  y as toBytes,
+  a as u32,
+  s as utf8ToBytes
 };

package/dist/native/index.native11.js

@@ -1,10 +1,10 @@
 import { logOutEndUser as l, refreshAccessToken as o, registerTemporaryWalletSecret as c } from "@coinbase/cdp-api-client";
-import { SignJWT as u } from "./index.native28.js";
-import { toAuthState as f } from "./index.native19.js";
+import { SignJWT as u } from "./index.native29.js";
+import { toAuthState as f } from "./index.native20.js";
 import "viem";
 import { getPlatformCrypto as n } from "./index.native6.js";
-import { sortKeys as S } from "./index.native24.js";
-import { getCoreOAuthManager as w } from "./index.native25.js";
+import { sortKeys as S } from "./index.native25.js";
+import { getCoreOAuthManager as w } from "./index.native26.js";
 const i = 60 * 1e3;
 class I {
   projectId;

package/dist/native/index.native110.js

@@ -1,7 +1,106 @@
-const e = 32, s = 4096, t = 131072, l = 761855;
+import { HashMD as D, SHA256_IV as b, Chi as g, Maj as p } from "./index.native121.js";
+import { createHasher as u, clean as C, rotr as i } from "./index.native109.js";
+const B = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), h = /* @__PURE__ */ new Uint32Array(64);
+class E extends D {
+  constructor(o = 32) {
+    super(64, o, 8, !1), this.A = b[0] | 0, this.B = b[1] | 0, this.C = b[2] | 0, this.D = b[3] | 0, this.E = b[4] | 0, this.F = b[5] | 0, this.G = b[6] | 0, this.H = b[7] | 0;
+  }
+  get() {
+    const { A: o, B: r, C: t, D: s, E: a, F: f, G: c, H: e } = this;
+    return [o, r, t, s, a, f, c, e];
+  }
+  // prettier-ignore
+  set(o, r, t, s, a, f, c, e) {
+    this.A = o | 0, this.B = r | 0, this.C = t | 0, this.D = s | 0, this.E = a | 0, this.F = f | 0, this.G = c | 0, this.H = e | 0;
+  }
+  process(o, r) {
+    for (let x = 0; x < 16; x++, r += 4)
+      h[x] = o.getUint32(r, !1);
+    for (let x = 16; x < 64; x++) {
+      const H = h[x - 15], d = h[x - 2], m = i(H, 7) ^ i(H, 18) ^ H >>> 3, l = i(d, 17) ^ i(d, 19) ^ d >>> 10;
+      h[x] = l + h[x - 7] + m + h[x - 16] | 0;
+    }
+    let { A: t, B: s, C: a, D: f, E: c, F: e, G: n, H: A } = this;
+    for (let x = 0; x < 64; x++) {
+      const H = i(c, 6) ^ i(c, 11) ^ i(c, 25), d = A + H + g(c, e, n) + B[x] + h[x] | 0, l = (i(t, 2) ^ i(t, 13) ^ i(t, 22)) + p(t, s, a) | 0;
+      A = n, n = e, e = c, c = f + d | 0, f = a, a = s, s = t, t = d + l | 0;
+    }
+    t = t + this.A | 0, s = s + this.B | 0, a = a + this.C | 0, f = f + this.D | 0, c = c + this.E | 0, e = e + this.F | 0, n = n + this.G | 0, A = A + this.H | 0, this.set(t, s, a, f, c, e, n, A);
+  }
+  roundClean() {
+    C(h);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), C(this.buffer);
+  }
+}
+const y = /* @__PURE__ */ u(() => new E());
 export {
-  t as bytesPerBlob,
-  e as bytesPerFieldElement,
-  s as fieldElementsPerBlob,
-  l as maxBytesPerTransaction
+  E as SHA256,
+  y as sha256
 };

package/dist/native/index.native111.js

@@ -1,15 +1,35 @@
-const s = {
-  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
-  l1Block: { address: "0x4200000000000000000000000000000000000015" },
-  l2CrossDomainMessenger: {
-    address: "0x4200000000000000000000000000000000000007"
-  },
-  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
-  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
-  l2ToL1MessagePasser: {
-    address: "0x4200000000000000000000000000000000000016"
+import { maxBytesPerTransaction as y, bytesPerBlob as a, fieldElementsPerBlob as f, bytesPerFieldElement as p } from "./index.native124.js";
+import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index.native81.js";
+import { createCursor as B } from "./index.native70.js";
+import { size as u } from "./index.native59.js";
+import { hexToBytes as x } from "./index.native51.js";
+import { bytesToHex as d } from "./index.native49.js";
+function S(e) {
+  const m = e.to ?? (typeof e.data == "string" ? "hex" : "bytes"), i = typeof e.data == "string" ? x(e.data) : e.data, o = u(i);
+  if (!o)
+    throw new c();
+  if (o > y)
+    throw new h({
+      maxSize: y,
+      size: o
+    });
+  const s = [];
+  let n = !0, r = 0;
+  for (; n; ) {
+    const t = B(new Uint8Array(a));
+    let l = 0;
+    for (; l < f; ) {
+      const b = i.slice(r, r + (p - 1));
+      if (t.pushByte(0), t.pushBytes(b), b.length < 31) {
+        t.pushByte(128), n = !1;
+        break;
+      }
+      l++, r += 31;
+    }
+    s.push(t);
   }
-};
+  return m === "bytes" ? s.map((t) => t.bytes) : s.map((t) => d(t.bytes));
+}
 export {
-  s as contracts
+  S as toBlobs
 };

package/dist/native/index.native112.js

@@ -1,38 +1,9 @@
-import { hexToBigInt as n } from "./index.native63.js";
-import { defineBlock as r } from "./index.native60.js";
-import { defineTransaction as s, formatTransaction as m } from "./index.native62.js";
-import { defineTransactionReceipt as l } from "./index.native65.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
-      };
-    }
-  })
-};
+import { bytesToHex as i } from "./index.native49.js";
+import { sha256 as m } from "./index.native73.js";
+function f(t) {
+  const { commitment: e, version: s = 1 } = t, n = t.to ?? (typeof e == "string" ? "hex" : "bytes"), o = m(e);
+  return o.set([s], 0), n === "bytes" ? o : i(o);
+}
 export {
-  p as formatters
+  f as commitmentToVersionedHash
 };

package/dist/native/index.native113.js

@@ -1,44 +1,23 @@
-import { InvalidAddressError as a } from "./index.native78.js";
-import { isAddress as f } from "./index.native52.js";
-import { concatHex as p } from "./index.native53.js";
-import { toHex as i } from "./index.native47.js";
-import { toRlp as x } from "./index.native66.js";
-import { serializeTransaction as l } from "./index.native26.js";
-function T(r, e) {
-  return h(r) ? z(r) : l(r, e);
+import { encoder as t, decoder as o } from "./index.native93.js";
+import { encodeBase64 as c, decodeBase64 as a } from "./index.native125.js";
+function i(r) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(typeof r == "string" ? r : o.decode(r), {
+      alphabet: "base64url"
+    });
+  let e = r;
+  e instanceof Uint8Array && (e = o.decode(e)), e = e.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "");
+  try {
+    return a(e);
+  } catch {
+    throw new TypeError("The input to be decoded is not correctly encoded.");
+  }
 }
-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 });
+function p(r) {
+  let e = r;
+  return typeof e == "string" && (e = t.encode(e)), Uint8Array.prototype.toBase64 ? e.toBase64({ alphabet: "base64url", omitPadding: !0 }) : c(e).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
 }
 export {
-  w as assertTransactionDeposit,
-  T as serializeTransaction,
-  E as serializers
+  i as decode,
+  p as encode
 };

package/dist/native/index.native114.js

@@ -1,20 +1,12 @@
-function o(t) {
-  if (Uint8Array.prototype.toBase64)
-    return t.toBase64();
-  const e = 32768, n = [];
-  for (let r = 0; r < t.length; r += e)
-    n.push(String.fromCharCode.apply(null, t.subarray(r, r + e)));
-  return btoa(n.join(""));
-}
-function a(t) {
-  if (Uint8Array.fromBase64)
-    return Uint8Array.fromBase64(t);
-  const e = atob(t), n = new Uint8Array(e.length);
-  for (let r = 0; r < e.length; r++)
-    n[r] = e.charCodeAt(r);
-  return n;
-}
+import n from "./index.native126.js";
+import s from "./index.native127.js";
+import a from "./index.native128.js";
+const y = async (t, o, e) => {
+  const r = await a(t, o, "sign");
+  s(t, r);
+  const i = await crypto.subtle.sign(n(t, r.algorithm), r, e);
+  return new Uint8Array(i);
+};
 export {
-  a as decodeBase64,
-  o as encodeBase64
+  y as default
 };

package/dist/native/index.native115.js

@@ -1,30 +1,22 @@
-import { JOSENotSupported as r } from "./index.native41.js";
-const S = (e, s) => {
-  const a = `SHA-${e.slice(-3)}`;
-  switch (e) {
-    case "HS256":
-    case "HS384":
-    case "HS512":
-      return { hash: a, name: "HMAC" };
-    case "PS256":
-    case "PS384":
-    case "PS512":
-      return { hash: a, name: "RSA-PSS", saltLength: parseInt(e.slice(-3), 10) >> 3 };
-    case "RS256":
-    case "RS384":
-    case "RS512":
-      return { hash: a, name: "RSASSA-PKCS1-v1_5" };
-    case "ES256":
-    case "ES384":
-    case "ES512":
-      return { hash: a, name: "ECDSA", namedCurve: s.namedCurve };
-    case "Ed25519":
-    case "EdDSA":
-      return { name: "Ed25519" };
-    default:
-      throw new r(`alg ${e} is not supported either by JOSE or your javascript runtime`);
+const a = (...o) => {
+  const t = o.filter(Boolean);
+  if (t.length === 0 || t.length === 1)
+    return !0;
+  let e;
+  for (const s of t) {
+    const r = Object.keys(s);
+    if (!e || e.size === 0) {
+      e = new Set(r);
+      continue;
+    }
+    for (const n of r) {
+      if (e.has(n))
+        return !1;
+      e.add(n);
+    }
   }
+  return !0;
 };
 export {
-  S as default
+  a as default
 };