@coinbase/cdp-core 0.0.25 → 0.0.26

package/dist/web/index.web8.js

@@ -0,0 +1,143 @@
+import "ox";
+import "viem";
+import "zustand";
+import "@coinbase/cdp-api-client";
+import { getCurrentUser as u } from "./index.web5.js";
+import "./index.web7.js";
+const r = {
+  rpc: {
+    invalidInput: -32e3,
+    resourceNotFound: -32001,
+    resourceUnavailable: -32002,
+    transactionRejected: -32003,
+    methodNotSupported: -32004,
+    limitExceeded: -32005,
+    parse: -32700,
+    invalidRequest: -32600,
+    methodNotFound: -32601,
+    invalidParams: -32602,
+    internal: -32603
+  },
+  provider: {
+    userRejectedRequest: 4001,
+    unauthorized: 4100,
+    unsupportedMethod: 4200,
+    disconnected: 4900,
+    chainDisconnected: 4901,
+    unsupportedChain: 4902
+  }
+};
+class o extends Error {
+  /**
+   * The error code from EIP1193ErrorCode enum.
+   */
+  code;
+  /**
+   * Creates a new EIP-1193 Provider error.
+   *
+   * @param code - The error code from EIP1193ErrorCode enum.
+   * @param message - The error message.
+   */
+  constructor(t, n) {
+    super(n), this.code = t;
+  }
+}
+class c extends Error {
+  /**
+   * The error code from RPCErrorCode type.
+   */
+  code;
+  /**
+   * Creates a new RPC Invalid Params error.
+   *
+   * @param code - The error code from RPCErrorCode type.
+   * @param message - The error message.
+   */
+  constructor(t, n) {
+    super(n), this.code = t;
+  }
+}
+const p = /* @__PURE__ */ new Set([
+  "eth_accounts",
+  "eth_requestAccounts",
+  "personal_sign",
+  "eth_sendTransaction",
+  "eth_signTypedData_v4",
+  "eth_chainId",
+  "eth_sign",
+  "wallet_disconnect",
+  "wallet_switchEthereumChain",
+  "wallet_sendCalls",
+  "wallet_getCallsStatus",
+  "wallet_getCapabilities"
+]);
+function _(e, { chains: t }) {
+  const { method: n, params: a } = e;
+  if (typeof n != "string" || n.length === 0)
+    throw new c(
+      r.rpc.invalidParams,
+      "'method' must be a non-empty string."
+    );
+  const s = (a ?? [])[0]?.chainId;
+  if (typeof s == "string" && !t.some((d) => d.id === Number.parseInt(s, 16)))
+    throw new o(
+      r.provider.unsupportedChain,
+      `Chain ${s} not supported - make sure the provider is configured with the correct chains.`
+    );
+  if (a !== void 0 && !Array.isArray(a))
+    throw new c(
+      r.rpc.invalidParams,
+      "'params' must be an array if provided."
+    );
+  if (!p.has(n))
+    throw new o(
+      r.provider.unsupportedMethod,
+      `Method ${e.method} not supported`
+    );
+}
+async function i() {
+  const e = await u();
+  if (!e)
+    throw new o(
+      r.provider.unauthorized,
+      "User not connected"
+    );
+  return e;
+}
+async function E(e) {
+  const t = await i();
+  if (!t.evmAccounts?.includes(e))
+    throw new o(
+      r.provider.unauthorized,
+      "Address not owned by user"
+    );
+  return t;
+}
+async function y() {
+  const e = await i();
+  if (!e.evmAccounts?.[0])
+    throw new o(
+      r.provider.unauthorized,
+      "No EVM accounts available"
+    );
+  return e;
+}
+async function A() {
+  const e = await i();
+  if (!e.evmSmartAccounts?.[0])
+    throw new o(
+      r.provider.unauthorized,
+      "No EVM smart accounts available"
+    );
+  return e;
+}
+export {
+  o as EIP1193ProviderError,
+  c as RPCRequestError,
+  r as STANDARD_ERROR_CODES,
+  _ as validateRequest,
+  i as validateUserConnected,
+  y as validateUserHasEvmAccount,
+  A as validateUserHasEvmSmartAccount,
+  E as validateUserOwnsAddress
+};

package/dist/web/index.web80.js

@@ -0,0 +1,81 @@
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.web81.js";
+function y(o, t, s, n) {
+  if (typeof o.setBigUint64 == "function")
+    return o.setBigUint64(t, s, n);
+  const i = BigInt(32), h = BigInt(4294967295), e = Number(s >> i & h), r = Number(s & h), c = n ? 4 : 0, u = n ? 0 : 4;
+  o.setUint32(t + c, e, n), o.setUint32(t + u, r, n);
+}
+function U(o, t, s) {
+  return o & t ^ ~o & s;
+}
+function _(o, t, s) {
+  return o & t ^ o & s ^ t & s;
+}
+class m extends g {
+  constructor(t, s, n, i) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = s, this.padOffset = n, this.isLE = i, this.buffer = new Uint8Array(t), this.view = l(this.buffer);
+  }
+  update(t) {
+    b(this), t = a(t), d(t);
+    const { view: s, buffer: n, blockLen: i } = this, h = t.length;
+    for (let e = 0; e < h; ) {
+      const r = Math.min(i - this.pos, h - e);
+      if (r === i) {
+        const c = l(t);
+        for (; i <= h - e; e += i)
+          this.process(c, e);
+        continue;
+      }
+      n.set(t.subarray(e, e + r), this.pos), this.pos += r, e += r, this.pos === i && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    b(this), x(t, this), this.finished = !0;
+    const { buffer: s, view: n, blockLen: i, isLE: h } = this;
+    let { pos: e } = this;
+    s[e++] = 128, w(this.buffer.subarray(e)), this.padOffset > i - e && (this.process(n, 0), e = 0);
+    for (let f = e; f < i; f++)
+      s[f] = 0;
+    y(n, i - 8, BigInt(this.length * 8), h), this.process(n, 0);
+    const r = l(t), c = this.outputLen;
+    if (c % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const u = c / 4, p = this.get();
+    if (u > p.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let f = 0; f < u; f++)
+      r.setUint32(4 * f, p[f], h);
+  }
+  digest() {
+    const { buffer: t, outputLen: s } = this;
+    this.digestInto(t);
+    const n = t.slice(0, s);
+    return this.destroy(), n;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: s, buffer: n, length: i, finished: h, destroyed: e, pos: r } = this;
+    return t.destroyed = e, t.finished = h, t.length = i, t.pos = r, i % s && t.buffer.set(n), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const B = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+export {
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
+};

package/dist/web/index.web81.js

@@ -0,0 +1,82 @@
+/*! 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 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/web/index.web82.js

@@ -0,0 +1,23 @@
+import { encoder as t, decoder as o } from "./index.web31.js";
+import { encodeBase64 as c, decodeBase64 as a } from "./index.web96.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.");
+  }
+}
+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 {
+  i as decode,
+  p as encode
+};

package/dist/web/index.web83.js

@@ -0,0 +1,12 @@
+import n from "./index.web97.js";
+import s from "./index.web98.js";
+import a from "./index.web99.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 {
+  y as default
+};

package/dist/web/index.web84.js

@@ -0,0 +1,22 @@
+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 {
+  a as default
+};

package/dist/web/index.web85.js

@@ -0,0 +1,96 @@
+import { withAlg as n } from "./index.web100.js";
+import c from "./index.web101.js";
+import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.web102.js";
+const s = (r) => r?.[Symbol.toStringTag], o = (r, e, t) => {
+  if (e.use !== void 0) {
+    let i;
+    switch (t) {
+      case "sign":
+      case "verify":
+        i = "sig";
+        break;
+      case "encrypt":
+      case "decrypt":
+        i = "enc";
+        break;
+    }
+    if (e.use !== i)
+      throw new TypeError(`Invalid key for this operation, its "use" must be "${i}" when present`);
+  }
+  if (e.alg !== void 0 && e.alg !== r)
+    throw new TypeError(`Invalid key for this operation, its "alg" must be "${r}" when present`);
+  if (Array.isArray(e.key_ops)) {
+    let i;
+    switch (!0) {
+      case t === "sign":
+      case r === "dir":
+      case r.includes("CBC-HS"):
+        i = t;
+        break;
+      case r.startsWith("PBES2"):
+        i = "deriveBits";
+        break;
+      case /^A\d{3}(?:GCM)?(?:KW)?$/.test(r):
+        !r.includes("GCM") && r.endsWith("KW") ? i = "unwrapKey" : i = t;
+        break;
+      case t === "encrypt":
+        i = "wrapKey";
+        break;
+      case t === "decrypt":
+        i = r.startsWith("RSA") ? "unwrapKey" : "deriveBits";
+        break;
+    }
+    if (i && e.key_ops?.includes?.(i) === !1)
+      throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${i}" when present`);
+  }
+  return !0;
+}, h = (r, e, t) => {
+  if (!(e instanceof Uint8Array)) {
+    if (p(e)) {
+      if (a(e) && o(r, e, t))
+        return;
+      throw new TypeError('JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present');
+    }
+    if (!c(e))
+      throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array"));
+    if (e.type !== "secret")
+      throw new TypeError(`${s(e)} instances for symmetric algorithms must be of type "secret"`);
+  }
+}, m = (r, e, t) => {
+  if (p(e))
+    switch (t) {
+      case "decrypt":
+      case "sign":
+        if (f(e) && o(r, e, t))
+          return;
+        throw new TypeError("JSON Web Key for this operation be a private JWK");
+      case "encrypt":
+      case "verify":
+        if (y(e) && o(r, e, t))
+          return;
+        throw new TypeError("JSON Web Key for this operation be a public JWK");
+    }
+  if (!c(e))
+    throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key"));
+  if (e.type === "secret")
+    throw new TypeError(`${s(e)} instances for asymmetric algorithms must not be of type "secret"`);
+  if (e.type === "public")
+    switch (t) {
+      case "sign":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm signing must be of type "private"`);
+      case "decrypt":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm decryption must be of type "private"`);
+    }
+  if (e.type === "private")
+    switch (t) {
+      case "verify":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm verifying must be of type "public"`);
+      case "encrypt":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm encryption must be of type "public"`);
+    }
+}, d = (r, e, t) => {
+  r.startsWith("HS") || r === "dir" || r.startsWith("PBES2") || /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(r) || /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(r) ? h(r, e, t) : m(r, e, t);
+};
+export {
+  d as default
+};

package/dist/web/index.web86.js

@@ -0,0 +1,23 @@
+import { JOSENotSupported as f } from "./index.web26.js";
+const w = (n, r, a, e, s) => {
+  if (s.crit !== void 0 && e?.crit === void 0)
+    throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');
+  if (!e || e.crit === void 0)
+    return /* @__PURE__ */ new Set();
+  if (!Array.isArray(e.crit) || e.crit.length === 0 || e.crit.some((i) => typeof i != "string" || i.length === 0))
+    throw new n('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
+  let t;
+  a !== void 0 ? t = new Map([...Object.entries(a), ...r.entries()]) : t = r;
+  for (const i of e.crit) {
+    if (!t.has(i))
+      throw new f(`Extension Header Parameter "${i}" is not recognized`);
+    if (s[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" is missing`);
+    if (t.get(i) && e[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" MUST be integrity protected`);
+  }
+  return new Set(e.crit);
+};
+export {
+  w as default
+};

package/dist/web/index.web87.js

@@ -0,0 +1,120 @@
+import { isJWK as p } from "./index.web102.js";
+import { decode as m } from "./index.web82.js";
+import y from "./index.web103.js";
+import { isCryptoKey as S, isKeyObject as K } from "./index.web101.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");
+};
+export {
+  d as default
+};

package/dist/web/index.web88.js

@@ -0,0 +1,4 @@
+const o = "2.33.0";
+export {
+  o as version
+};

package/dist/web/index.web89.js

@@ -0,0 +1,23 @@
+import { BaseError as o } from "./index.web56.js";
+class i extends o {
+  constructor({ offset: e }) {
+    super(`Offset \`${e}\` cannot be negative.`, {
+      name: "NegativeOffsetError"
+    });
+  }
+}
+class n extends o {
+  constructor({ length: e, position: r }) {
+    super(`Position \`${r}\` is out of bounds (\`0 < position < ${e}\`).`, { name: "PositionOutOfBoundsError" });
+  }
+}
+class c extends o {
+  constructor({ count: e, limit: r }) {
+    super(`Recursive read limit of \`${r}\` exceeded (recursive read count: \`${e}\`).`, { name: "RecursiveReadLimitExceededError" });
+  }
+}
+export {
+  i as NegativeOffsetError,
+  n as PositionOutOfBoundsError,
+  c as RecursiveReadLimitExceededError
+};