@coinbase/cdp-core 0.0.25 → 0.0.27

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/{index27.js → index.web30.js}

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

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

@@ -1,6 +1,6 @@
-import { IntegerOutOfRangeError as x } from "./index50.js";
-import { pad as s } from "./index36.js";
-import { assertSize as c } from "./index44.js";
+import { IntegerOutOfRangeError as x } from "./index.web53.js";
+import { pad as s } from "./index.web39.js";
+import { assertSize as c } from "./index.web47.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/{index29.js → index.web32.js}

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

package/dist/esm/{index30.js → index.web33.js}

@@ -1,8 +1,8 @@
-import { BaseError as g } from "./index48.js";
-import { isHex as x } from "./index35.js";
-import { pad as s } from "./index36.js";
-import { assertSize as u } from "./index44.js";
-import { numberToHex as h } from "./index28.js";
+import { BaseError as g } from "./index.web51.js";
+import { isHex as x } from "./index.web38.js";
+import { pad as s } from "./index.web39.js";
+import { assertSize as u } from "./index.web47.js";
+import { numberToHex as h } from "./index.web31.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.web34.js

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

package/dist/esm/index.web35.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/{index33.js → index.web36.js}

@@ -1,5 +1,5 @@
-import { LruMap as u } from "./index32.js";
-import { checksumAddress as c } from "./index29.js";
+import { LruMap as u } from "./index.web35.js";
+import { checksumAddress as c } from "./index.web32.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.web37.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.web38.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/{index36.js → index.web39.js}

@@ -1,4 +1,4 @@
-import { SizeExceedsPaddingSizeError as d } from "./index37.js";
+import { SizeExceedsPaddingSizeError as d } from "./index.web40.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/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/{index37.js → index.web40.js}

@@ -1,4 +1,4 @@
-import { BaseError as o } from "./index48.js";
+import { BaseError as o } from "./index.web51.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/{index38.js → index.web41.js}

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

package/dist/esm/{index39.js → index.web42.js}

@@ -1,6 +1,6 @@
-import { SliceOffsetOutOfBoundsError as n } from "./index37.js";
-import { isHex as c } from "./index35.js";
-import { size as s } from "./index38.js";
+import { SliceOffsetOutOfBoundsError as n } from "./index.web40.js";
+import { isHex as c } from "./index.web38.js";
+import { size as s } from "./index.web41.js";
 function O(e, f, i, { strict: o } = {}) {
   return c(e, { strict: !1 }) ? l(e, f, i, {
     strict: o

package/dist/esm/index.web43.js

@@ -0,0 +1,9 @@
+function f(e, { dir: n = "left" } = {}) {
+  let t = typeof e == "string" ? e.replace("0x", "") : e, i = 0;
+  for (let l = 0; l < t.length - 1 && t[n === "left" ? l : t.length - l - 1].toString() === "0"; l++)
+    i++;
+  return t = n === "left" ? t.slice(i) : t.slice(0, t.length - i), typeof e == "string" ? (t.length === 1 && n === "right" && (t = `${t}0`), `0x${t.length % 2 === 1 ? `0${t}` : t}`) : t;
+}
+export {
+  f as trim
+};

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

@@ -1,5 +1,5 @@
-import { defineFormatter as s } from "./index42.js";
-import { formatTransaction as t } from "./index43.js";
+import { defineFormatter as s } from "./index.web45.js";
+import { formatTransaction as t } from "./index.web46.js";
 function a(e) {
   const i = (e.transactions ?? []).map((n) => typeof n == "string" ? n : t(n));
   return {

package/dist/esm/index.web45.js

@@ -0,0 +1,19 @@
+function a(e, f) {
+  return ({ exclude: t, format: n }) => ({
+    exclude: t,
+    format: (r) => {
+      const o = f(r);
+      if (t)
+        for (const m of t)
+          delete o[m];
+      return {
+        ...o,
+        ...n(r)
+      };
+    },
+    type: e
+  });
+}
+export {
+  a as defineFormatter
+};

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

@@ -1,5 +1,5 @@
-import { hexToNumber as i } from "./index44.js";
-import { defineFormatter as r } from "./index42.js";
+import { hexToNumber as i } from "./index.web47.js";
+import { defineFormatter as r } from "./index.web45.js";
 const u = {
   "0x0": "legacy",
   "0x1": "eip2930",

package/dist/esm/{index44.js → index.web47.js}

@@ -1,5 +1,5 @@
-import { SizeOverflowError as u } from "./index50.js";
-import { size as t } from "./index38.js";
+import { SizeOverflowError as u } from "./index.web53.js";
+import { size as t } from "./index.web41.js";
 function s(n, { size: i }) {
   if (t(n) > i)
     throw new u({

package/dist/esm/index.web48.js

@@ -0,0 +1,14 @@
+function r(n, { args: t, eventName: a } = {}) {
+  return {
+    ...n,
+    blockHash: n.blockHash ? n.blockHash : null,
+    blockNumber: n.blockNumber ? BigInt(n.blockNumber) : null,
+    logIndex: n.logIndex ? Number(n.logIndex) : null,
+    transactionHash: n.transactionHash ? n.transactionHash : null,
+    transactionIndex: n.transactionIndex ? Number(n.transactionIndex) : null,
+    ...a ? { args: t, eventName: a } : {}
+  };
+}
+export {
+  r as formatLog
+};

package/dist/esm/{index46.js → index.web49.js}

@@ -1,7 +1,7 @@
-import { hexToNumber as d } from "./index44.js";
-import { defineFormatter as b } from "./index42.js";
-import { formatLog as m } from "./index45.js";
-import { transactionType as o } from "./index43.js";
+import { hexToNumber as d } from "./index.web47.js";
+import { defineFormatter as b } from "./index.web45.js";
+import { formatLog as m } from "./index.web48.js";
+import { transactionType as o } from "./index.web46.js";
 const f = {
   "0x0": "reverted",
   "0x1": "success"