@coinbase/cdp-core 0.0.24 → 0.0.26

package/dist/esm/index.web21.js

@@ -0,0 +1,162 @@
+const H = (m) => (h, n, r) => {
+  const s = r.subscribe;
+  return r.subscribe = (c, i, a) => {
+    let l = c;
+    if (i) {
+      const g = a?.equalityFn || Object.is;
+      let v = c(r.getState());
+      l = (f) => {
+        const u = c(f);
+        if (!g(v, u)) {
+          const y = v;
+          i(v = u, y);
+        }
+      }, a?.fireImmediately && i(v, v);
+    }
+    return s(l);
+  }, m(h, n, r);
+}, R = H;
+function F(m, h) {
+  let n;
+  try {
+    n = m();
+  } catch {
+    return;
+  }
+  return {
+    getItem: (s) => {
+      var e;
+      const c = (a) => a === null ? null : JSON.parse(a, void 0), i = (e = n.getItem(s)) != null ? e : null;
+      return i instanceof Promise ? i.then(c) : c(i);
+    },
+    setItem: (s, e) => n.setItem(s, JSON.stringify(e, void 0)),
+    removeItem: (s) => n.removeItem(s)
+  };
+}
+const p = (m) => (h) => {
+  try {
+    const n = m(h);
+    return n instanceof Promise ? n : {
+      then(r) {
+        return p(r)(n);
+      },
+      catch(r) {
+        return this;
+      }
+    };
+  } catch (n) {
+    return {
+      then(r) {
+        return this;
+      },
+      catch(r) {
+        return p(r)(n);
+      }
+    };
+  }
+}, O = (m, h) => (n, r, s) => {
+  let e = {
+    storage: F(() => localStorage),
+    partialize: (t) => t,
+    version: 0,
+    merge: (t, S) => ({
+      ...S,
+      ...t
+    }),
+    ...h
+  }, c = !1;
+  const i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
+  let l = e.storage;
+  if (!l)
+    return m(
+      (...t) => {
+        console.warn(
+          `[zustand persist middleware] Unable to update item '${e.name}', the given storage is currently unavailable.`
+        ), n(...t);
+      },
+      r,
+      s
+    );
+  const g = () => {
+    const t = e.partialize({ ...r() });
+    return l.setItem(e.name, {
+      state: t,
+      version: e.version
+    });
+  }, v = s.setState;
+  s.setState = (t, S) => {
+    v(t, S), g();
+  };
+  const f = m(
+    (...t) => {
+      n(...t), g();
+    },
+    r,
+    s
+  );
+  s.getInitialState = () => f;
+  let u;
+  const y = () => {
+    var t, S;
+    if (!l) return;
+    c = !1, i.forEach((o) => {
+      var d;
+      return o((d = r()) != null ? d : f);
+    });
+    const b = ((S = e.onRehydrateStorage) == null ? void 0 : S.call(e, (t = r()) != null ? t : f)) || void 0;
+    return p(l.getItem.bind(l))(e.name).then((o) => {
+      if (o)
+        if (typeof o.version == "number" && o.version !== e.version) {
+          if (e.migrate) {
+            const d = e.migrate(
+              o.state,
+              o.version
+            );
+            return d instanceof Promise ? d.then((I) => [!0, I]) : [!0, d];
+          }
+          console.error(
+            "State loaded from storage couldn't be migrated since no migrate function was provided"
+          );
+        } else
+          return [!1, o.state];
+      return [!1, void 0];
+    }).then((o) => {
+      var d;
+      const [I, _] = o;
+      if (u = e.merge(
+        _,
+        (d = r()) != null ? d : f
+      ), n(u, !0), I)
+        return g();
+    }).then(() => {
+      b?.(u, void 0), u = r(), c = !0, a.forEach((o) => o(u));
+    }).catch((o) => {
+      b?.(void 0, o);
+    });
+  };
+  return s.persist = {
+    setOptions: (t) => {
+      e = {
+        ...e,
+        ...t
+      }, t.storage && (l = t.storage);
+    },
+    clearStorage: () => {
+      l?.removeItem(e.name);
+    },
+    getOptions: () => e,
+    rehydrate: () => y(),
+    hasHydrated: () => c,
+    onHydrate: (t) => (i.add(t), () => {
+      i.delete(t);
+    }),
+    onFinishHydration: (t) => (a.add(t), () => {
+      a.delete(t);
+    })
+  }, e.skipHydration || y(), u || f;
+}, w = O;
+export {
+  F as createJSONStorage,
+  w as persist,
+  R as subscribeWithSelector
+};

package/dist/esm/index.web22.js

@@ -0,0 +1,50 @@
+class n {
+  events = {};
+  /**
+   * Add an event listener.
+   *
+   * @param event - The name of the event to listen for.
+   * @param listener - The function to call when the event is emitted.
+   */
+  on(e, s) {
+    this.events[e] || (this.events[e] = []), this.events[e].push(s);
+  }
+  /**
+   * Remove an event listener.
+   *
+   * @param event - The name of the event to remove the listener from.
+   * @param listener - The function to remove from the event listeners.
+   */
+  removeListener(e, s) {
+    if (!this.events[e])
+      return;
+    const t = this.events[e].indexOf(s);
+    t > -1 && this.events[e].splice(t, 1);
+  }
+  /**
+   * Emit an event.
+   *
+   * @param event - The name of the event to emit.
+   * @param args - The arguments to pass to the event listeners.
+   */
+  emit(e, ...s) {
+    this.events[e] && this.events[e].forEach((t) => {
+      try {
+        t(...s);
+      } catch (i) {
+        console.error(`Error in event listener for ${e}:`, i);
+      }
+    });
+  }
+  /**
+   * Remove all listeners for an event.
+   *
+   * @param event - The name of the event to remove all listeners from. If not provided, removes all listeners for all events.
+   */
+  removeAllListeners(e) {
+    e ? delete this.events[e] : this.events = {};
+  }
+}
+export {
+  n as EventEmitter
+};

package/dist/esm/{index23.js → index.web23.js}

@@ -1,11 +1,11 @@
 import { Hex as P } from "ox";
 import { toHex as f, createWalletClient as A } from "viem";
-import { getUserOperation as T, sendUserOperation as R, signEvmTypedData as U, signEvmHash as x, getCurrentUser as v, signOut as O, sendEvmTransaction as b, signEvmTransaction as D, signEvmMessage as H } from "./index2.js";
+import { getUserOperation as T, sendUserOperation as R, signEvmTypedData as U, signEvmHash as x, getCurrentUser as v, signOut as O, sendEvmTransaction as b, signEvmTransaction as D, signEvmMessage as H } from "./index.web5.js";
 import "@coinbase/cdp-api-client";
-import "./index3.js";
-import { validateUserConnected as g, RPCRequestError as i, STANDARD_ERROR_CODES as s, validateUserHasEvmSmartAccount as S, validateUserOwnsAddress as l, EIP1193ProviderError as p, validateUserHasEvmAccount as F } from "./index4.js";
+import "./index.web7.js";
+import { validateUserConnected as g, RPCRequestError as i, STANDARD_ERROR_CODES as s, validateUserHasEvmSmartAccount as S, validateUserOwnsAddress as l, EIP1193ProviderError as p, validateUserHasEvmAccount as F } from "./index.web8.js";
 import "zustand";
-import { userOperationChainIdToNameMapping as m, isChainIdSupportedForCDPUserOps as I, isChainIdSupportedForCDPSends as N, sendTransactionChainIdToNameMapping as j, userOperationNameToChainIdMapping as q } from "./index13.js";
+import { userOperationChainIdToNameMapping as m, isChainIdSupportedForCDPUserOps as I, isChainIdSupportedForCDPSends as N, sendTransactionChainIdToNameMapping as j, userOperationNameToChainIdMapping as q } from "./index.web16.js";
 function w(e) {
   return {
     to: e.to,

package/dist/esm/{index24.js → index.web24.js}

@@ -1,5 +1,5 @@
-import { chainConfig as a } from "./index85.js";
-import { defineChain as t } from "./index25.js";
+import { chainConfig as a } from "./index.web78.js";
+import { defineChain as t } from "./index.web35.js";
 const e = 11155111, r = /* @__PURE__ */ t({
   ...a,
   id: 84532,

package/dist/esm/{index70.js → index.web25.js}

@@ -1,4 +1,4 @@
-import { FlattenedSign as n } from "./index80.js";
+import { FlattenedSign as n } from "./index.web30.js";
 class o {
   #e;
   constructor(e) {

package/dist/esm/index.web26.js

@@ -0,0 +1,25 @@
+class c extends Error {
+  static code = "ERR_JOSE_GENERIC";
+  code = "ERR_JOSE_GENERIC";
+  constructor(s, e) {
+    super(s, e), this.name = this.constructor.name, Error.captureStackTrace?.(this, this.constructor);
+  }
+}
+class E extends c {
+  static code = "ERR_JOSE_NOT_SUPPORTED";
+  code = "ERR_JOSE_NOT_SUPPORTED";
+}
+class o extends c {
+  static code = "ERR_JWS_INVALID";
+  code = "ERR_JWS_INVALID";
+}
+class r extends c {
+  static code = "ERR_JWT_INVALID";
+  code = "ERR_JWT_INVALID";
+}
+export {
+  c as JOSEError,
+  E as JOSENotSupported,
+  o as JWSInvalid,
+  r as JWTInvalid
+};

package/dist/esm/{index72.js → index.web27.js}

@@ -1,7 +1,7 @@
-import { encoder as n } from "./index81.js";
-import e from "./index82.js";
-import i from "./index83.js";
-import o from "./index84.js";
+import { encoder as n } from "./index.web31.js";
+import e from "./index.web32.js";
+import i from "./index.web33.js";
+import o from "./index.web34.js";
 function s(r, t) {
   if (!Number.isFinite(t))
     throw new TypeError(`Invalid ${r} input`);

package/dist/esm/{index58.js → index.web28.js}

@@ -1,4 +1,4 @@
-import { BaseError as r } from "./index47.js";
+import { BaseError as r } from "./index.web56.js";
 class d extends r {
   constructor({ address: s }) {
     super(`Address "${s}" is invalid.`, {

package/dist/esm/{index32.js → index.web29.js}

@@ -1,5 +1,5 @@
-import { LruMap as u } from "./index31.js";
-import { checksumAddress as c } from "./index28.js";
+import { LruMap as u } from "./index.web41.js";
+import { checksumAddress as c } from "./index.web38.js";
 const i = /^0x[a-fA-F0-9]{40}$/, r = /* @__PURE__ */ new u(8192);
 function h(t, s) {
   const { strict: n = !0 } = s ?? {}, e = `${t}.${n}`;

package/dist/esm/index.web3.js

@@ -0,0 +1,78 @@
+import { decodeBase64 as y, encodeBase64 as n } from "./index.web11.js";
+const c = {
+  /**
+   * Creates a secp256r1 key pair for the browser.
+   *
+   * @returns A secp256r1 key pair with private key and base64-encoded public key.
+   */
+  async createKeyPair() {
+    const e = await window.crypto.subtle.generateKey(
+      {
+        name: "ECDSA",
+        namedCurve: "P-256"
+        // secp256r1
+      },
+      !1,
+      // Do not allow key export.
+      ["sign", "verify"]
+      // Key usages
+    ), t = await window.crypto.subtle.exportKey("spki", e.publicKey), r = new Uint8Array(t), a = n(r);
+    return { privateKey: e.privateKey, publicKeyBase64: a };
+  },
+  /**
+   * Creates an RSA key pair that allows private key export.
+   *
+   * @returns An RSA key pair with exportable private key and base64-encoded public key.
+   */
+  async createExportKeyPair() {
+    const e = await window.crypto.subtle.generateKey(
+      {
+        name: "RSA-OAEP",
+        modulusLength: 2048,
+        publicExponent: new Uint8Array([1, 0, 1]),
+        hash: "SHA-256"
+      },
+      !0,
+      // Allow key export
+      ["encrypt", "decrypt"]
+    ), t = await window.crypto.subtle.exportKey("spki", e.publicKey), r = n(new Uint8Array(t));
+    return { privateKey: e.privateKey, publicKeyBase64: r };
+  },
+  /**
+   * Computes a hash of the given data.
+   *
+   * @param data - The data to hash.
+   * @returns Promise that resolves to the hex-encoded hash.
+   */
+  async hash(e) {
+    const t = await window.crypto.subtle.digest("SHA-256", e), r = new Uint8Array(t);
+    return Array.from(r).map((o) => o.toString(16).padStart(2, "0")).join("");
+  },
+  /**
+   * Generates a cryptographically secure random identifier.
+   *
+   * @returns A random string suitable for use as an identifier.
+   */
+  generateRandomId() {
+    const e = new Uint8Array(16);
+    return window.crypto.getRandomValues(e), Array.from(e, (t) => t.toString(16).padStart(2, "0")).join("");
+  },
+  /**
+   * Decrypts data using a private key with RSA-OAEP algorithm.
+   *
+   * @param privateKey - The private key to use for decryption.
+   * @param encryptedData - Base64-encoded encrypted data.
+   * @returns Promise that resolves to the decrypted string.
+   */
+  async decryptWithPrivateKey(e, t) {
+    const r = y(t), a = await window.crypto.subtle.decrypt(
+      "RSA-OAEP",
+      e,
+      r
+    );
+    return new TextDecoder().decode(a);
+  }
+};
+export {
+  c as webCrypto
+};

package/dist/esm/{index80.js → index.web30.js}

@@ -1,11 +1,11 @@
-import { encode as d } from "./index88.js";
-import y from "./index89.js";
-import b from "./index90.js";
-import { JWSInvalid as r } from "./index71.js";
-import { encoder as s, concat as u, decoder as h } from "./index81.js";
-import g from "./index91.js";
-import H from "./index92.js";
-import P from "./index93.js";
+import { encode as d } from "./index.web82.js";
+import y from "./index.web83.js";
+import b from "./index.web84.js";
+import { JWSInvalid as r } from "./index.web26.js";
+import { encoder as s, concat as u, decoder as h } from "./index.web31.js";
+import g from "./index.web85.js";
+import H from "./index.web86.js";
+import P from "./index.web87.js";
 class x {
   #r;
   #e;

package/dist/esm/index.web31.js

@@ -0,0 +1,13 @@
+const d = new TextEncoder(), s = new TextDecoder();
+function f(...n) {
+  const c = n.reduce((e, { length: r }) => e + r, 0), t = new Uint8Array(c);
+  let o = 0;
+  for (const e of n)
+    t.set(e, o), o += e.length;
+  return t;
+}
+export {
+  f as concat,
+  s as decoder,
+  d as encoder
+};

package/dist/esm/index.web32.js

@@ -0,0 +1,4 @@
+const o = (e) => Math.floor(e.getTime() / 1e3);
+export {
+  o as default
+};

package/dist/esm/index.web33.js

@@ -0,0 +1,47 @@
+const o = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i, t = (c) => {
+  const s = o.exec(c);
+  if (!s || s[4] && s[1])
+    throw new TypeError("Invalid time period format");
+  const a = parseFloat(s[2]), r = s[3].toLowerCase();
+  let e;
+  switch (r) {
+    case "sec":
+    case "secs":
+    case "second":
+    case "seconds":
+    case "s":
+      e = Math.round(a);
+      break;
+    case "minute":
+    case "minutes":
+    case "min":
+    case "mins":
+    case "m":
+      e = Math.round(a * 60);
+      break;
+    case "hour":
+    case "hours":
+    case "hr":
+    case "hrs":
+    case "h":
+      e = Math.round(a * 3600);
+      break;
+    case "day":
+    case "days":
+    case "d":
+      e = Math.round(a * 86400);
+      break;
+    case "week":
+    case "weeks":
+    case "w":
+      e = Math.round(a * 604800);
+      break;
+    default:
+      e = Math.round(a * 31557600);
+      break;
+  }
+  return s[1] === "-" || s[4] === "ago" ? -e : e;
+};
+export {
+  t as default
+};

package/dist/esm/index.web34.js

@@ -0,0 +1,16 @@
+function o(t) {
+  return typeof t == "object" && t !== null;
+}
+const r = (t) => {
+  if (!o(t) || Object.prototype.toString.call(t) !== "[object Object]")
+    return !1;
+  if (Object.getPrototypeOf(t) === null)
+    return !0;
+  let e = t;
+  for (; Object.getPrototypeOf(e) !== null; )
+    e = Object.getPrototypeOf(e);
+  return Object.getPrototypeOf(t) === e;
+};
+export {
+  r as default
+};

package/dist/esm/index.web35.js

@@ -0,0 +1,11 @@
+function n(e) {
+  return {
+    formatters: void 0,
+    fees: void 0,
+    serializers: void 0,
+    ...e
+  };
+}
+export {
+  n as defineChain
+};

package/dist/esm/{index26.js → index.web36.js}

@@ -1,5 +1,5 @@
-import { toHex as i } from "./index27.js";
-import { toYParitySignatureArray as c } from "./index15.js";
+import { toHex as i } from "./index.web37.js";
+import { toYParitySignatureArray as c } from "./index.web18.js";
 function f(r) {
   if (!r || r.length === 0)
     return [];

package/dist/esm/{index27.js → index.web37.js}

@@ -1,6 +1,6 @@
-import { IntegerOutOfRangeError as x } from "./index49.js";
-import { pad as s } from "./index35.js";
-import { assertSize as c } from "./index43.js";
+import { IntegerOutOfRangeError as x } from "./index.web58.js";
+import { pad as s } from "./index.web44.js";
+import { assertSize as c } from "./index.web52.js";
 const b = /* @__PURE__ */ Array.from({ length: 256 }, (n, e) => e.toString(16).padStart(2, "0"));
 function B(n, e = {}) {
   return typeof n == "number" || typeof n == "bigint" ? y(n, e) : typeof n == "string" ? $(n, e) : typeof n == "boolean" ? z(n, e) : m(n, e);

package/dist/esm/{index28.js → index.web38.js}

@@ -1,6 +1,6 @@
-import { stringToBytes as p } from "./index29.js";
-import { keccak256 as f } from "./index30.js";
-import { LruMap as m } from "./index31.js";
+import { stringToBytes as p } from "./index.web39.js";
+import { keccak256 as f } from "./index.web40.js";
+import { LruMap as m } from "./index.web41.js";
 const r = /* @__PURE__ */ new m(8192);
 function a(s, o) {
   if (r.has(`${s}.${o}`))

package/dist/esm/{index29.js → index.web39.js}

@@ -1,8 +1,8 @@
-import { BaseError as g } from "./index47.js";
-import { isHex as x } from "./index34.js";
-import { pad as s } from "./index35.js";
-import { assertSize as u } from "./index43.js";
-import { numberToHex as h } from "./index27.js";
+import { BaseError as g } from "./index.web56.js";
+import { isHex as x } from "./index.web43.js";
+import { pad as s } from "./index.web44.js";
+import { assertSize as u } from "./index.web52.js";
+import { numberToHex as h } from "./index.web37.js";
 const A = /* @__PURE__ */ new TextEncoder();
 function F(e, n = {}) {
   return typeof e == "number" || typeof e == "bigint" ? T(e, n) : typeof e == "boolean" ? B(e, n) : x(e) ? y(e, n) : l(e, n);

package/dist/esm/index.web4.js

@@ -0,0 +1,57 @@
+const t = {
+  /**
+   * Retrieves a value from localStorage.
+   *
+   * @param key - The storage key.
+   * @returns Promise that resolves to the value.
+   */
+  async getItem(e) {
+    try {
+      return localStorage.getItem(e);
+    } catch (r) {
+      return console.warn(`Failed to get item from localStorage: ${r}`), null;
+    }
+  },
+  /**
+   * Stores a value in localStorage.
+   *
+   * @param key - The storage key.
+   * @param value - The value to store.
+   * @returns Promise that resolves when the value is stored.
+   */
+  async setItem(e, r) {
+    try {
+      localStorage.setItem(e, r);
+    } catch (o) {
+      throw console.warn(`Failed to set item in localStorage: ${o}`), o;
+    }
+  },
+  /**
+   * Removes a value from localStorage.
+   *
+   * @param key - The storage key.
+   * @returns Promise that resolves when the value is removed.
+   */
+  async removeItem(e) {
+    try {
+      localStorage.removeItem(e);
+    } catch (r) {
+      throw console.warn(`Failed to remove item from localStorage: ${r}`), r;
+    }
+  },
+  /**
+   * Clears all values from localStorage.
+   *
+   * @returns Promise that resolves when storage is cleared.
+   */
+  async clear() {
+    try {
+      localStorage.clear();
+    } catch (e) {
+      throw console.warn(`Failed to clear localStorage: ${e}`), e;
+    }
+  }
+};
+export {
+  t as webStorage
+};

package/dist/esm/index.web40.js

@@ -0,0 +1,9 @@
+import { keccak_256 as o } from "./index.web59.js";
+import { isHex as r } from "./index.web43.js";
+import { toBytes as c } from "./index.web39.js";
+function k(t, e) {
+  return o(r(t, { strict: !1 }) ? c(t) : t);
+}
+export {
+  k as keccak256
+};

package/dist/esm/index.web41.js

@@ -0,0 +1,24 @@
+class r extends Map {
+  constructor(e) {
+    super(), Object.defineProperty(this, "maxSize", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.maxSize = e;
+  }
+  get(e) {
+    const t = super.get(e);
+    return super.has(e) && t !== void 0 && (this.delete(e), super.set(e, t)), t;
+  }
+  set(e, t) {
+    if (super.set(e, t), this.maxSize && this.size > this.maxSize) {
+      const s = this.keys().next().value;
+      s && this.delete(s);
+    }
+    return this;
+  }
+}
+export {
+  r as LruMap
+};

package/dist/esm/index.web42.js

@@ -0,0 +1,6 @@
+function n(e) {
+  return `0x${e.reduce((c, r) => c + r.replace("0x", ""), "")}`;
+}
+export {
+  n as concatHex
+};

package/dist/esm/index.web43.js

@@ -0,0 +1,6 @@
+function e(t, { strict: r = !0 } = {}) {
+  return !t || typeof t != "string" ? !1 : r ? /^0x[0-9a-fA-F]*$/.test(t) : t.startsWith("0x");
+}
+export {
+  e as isHex
+};

package/dist/esm/{index35.js → index.web44.js}

@@ -1,4 +1,4 @@
-import { SizeExceedsPaddingSizeError as d } from "./index36.js";
+import { SizeExceedsPaddingSizeError as d } from "./index.web45.js";
 function f(n, { dir: r, size: t = 32 } = {}) {
   return typeof n == "string" ? p(n, { dir: r, size: t }) : i(n, { dir: r, size: t });
 }

package/dist/esm/{index36.js → index.web45.js}

@@ -1,4 +1,4 @@
-import { BaseError as o } from "./index47.js";
+import { BaseError as o } from "./index.web56.js";
 class d extends o {
   constructor({ offset: r, position: s, size: e }) {
     super(`Slice ${s === "start" ? "starting" : "ending"} at offset "${r}" is out-of-bounds (size: ${e}).`, { name: "SliceOffsetOutOfBoundsError" });

package/dist/esm/{index37.js → index.web46.js}

@@ -1,4 +1,4 @@
-import { isHex as r } from "./index34.js";
+import { isHex as r } from "./index.web43.js";
 function i(t) {
   return r(t, { strict: !1 }) ? Math.ceil((t.length - 2) / 2) : t.length;
 }