@coinbase/cdp-core 0.0.17 → 0.0.18

package/dist/esm/index22.js

@@ -1,19 +1,50 @@
-async function n() {
-  const e = await window.crypto.subtle.generateKey(
-    {
-      name: "ECDSA",
-      namedCurve: "P-256"
-      // secp256r1
-    },
-    !1,
-    // Do not allow key export.
-    ["sign", "verify"]
-    // Key usages
-  ), r = await window.crypto.subtle.exportKey("spki", e.publicKey), t = new Uint8Array(r), a = btoa(
-    Array.from(t).map((i) => String.fromCharCode(i)).join("")
-  );
-  return { privateKey: e.privateKey, publicKeyBase64: a };
+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 createKeyPair
+  n as EventEmitter
 };

package/dist/esm/index23.js

@@ -1,7 +1,155 @@
-async function t() {
-  const r = new Uint8Array(16);
-  return window.crypto.getRandomValues(r), Array.from(r, (n) => n.toString(16).padStart(2, "0")).join("");
+import { Hex as y } from "ox";
+import { createWalletClient as I } from "viem";
+import { signEvmTypedData as E, signEvmHash as S, getCurrentUser as f, signOut as P, sendEvmTransaction as R, signEvmTransaction as T, signEvmMessage as A } from "./index2.js";
+import "@coinbase/cdp-api-client";
+import "./index3.js";
+import { validateUserOwnsAddress as m, EIP1193ProviderError as l, STANDARD_ERROR_CODES as s, RPCRequestError as o, validateUserHasEvmAccount as x, validateUserConnected as C } from "./index4.js";
+import "zustand";
+import { isChainIdSupportedForCDPSends as D, chainIdToNameMapping as b } from "./index13.js";
+function g(e) {
+  return {
+    to: e.to,
+    data: e.data,
+    value: e.value ? BigInt(e.value) : void 0,
+    nonce: e.nonce ? Number(e.nonce) : void 0,
+    gas: e.gas ? BigInt(e.gas) : void 0,
+    maxFeePerGas: e.maxFeePerGas ? BigInt(e.maxFeePerGas) : void 0,
+    maxPriorityFeePerGas: e.maxPriorityFeePerGas ? BigInt(e.maxPriorityFeePerGas) : void 0,
+    type: "eip1559"
+  };
+}
+async function M() {
+  return (await f())?.evmAccounts || [];
+}
+async function _(e, n) {
+  const a = await C();
+  return e.emit("connect", {
+    chainId: y.fromNumber(n.getState().chainId)
+  }), a.evmAccounts || [];
+}
+async function k(e) {
+  const [n, a] = e;
+  await m(a);
+  const t = Buffer.from(n.slice(2), "hex").toString();
+  try {
+    return (await A({
+      evmAccount: a,
+      message: t
+    })).signature;
+  } catch (c) {
+    throw new l(
+      s.provider.userRejectedRequest,
+      c instanceof Error ? c.message : "Signing failed"
+    );
+  }
+}
+async function z(e) {
+  const [n, a] = e;
+  await m(n);
+  try {
+    return (await E({
+      evmAccount: n,
+      typedData: JSON.parse(a)
+    })).signature;
+  } catch (t) {
+    throw new l(
+      s.provider.userRejectedRequest,
+      t instanceof Error ? t.message : "Signing failed"
+    );
+  }
+}
+async function J(e, n, a) {
+  const [t] = e;
+  if (!t || typeof t != "object")
+    throw new o(
+      s.rpc.invalidParams,
+      "Transaction parameter must be an object"
+    );
+  if (!t.to)
+    throw new o(
+      s.rpc.invalidParams,
+      "Transaction must include 'to' field"
+    );
+  const d = (await x()).evmAccounts?.[0], u = n.getState(), i = t.chainId ? Number(t.chainId) : u.chainId;
+  if (!d)
+    throw new o(
+      s.rpc.invalidParams,
+      "User does not have an EVM account"
+    );
+  if (D(i))
+    try {
+      return (await R({
+        evmAccount: d,
+        transaction: { ...g(t), chainId: i },
+        network: b[i]
+      })).transactionHash;
+    } catch (r) {
+      throw console.log("Transaction failed", r), new o(
+        s.rpc.transactionRejected,
+        r instanceof Error ? r.message : "Transaction failed"
+      );
+    }
+  else
+    try {
+      const r = I({
+        // Safe as we check before calling this handler that chainId is configured
+        chain: u.chains.find((h) => h.id === i),
+        transport: a[i],
+        account: d
+      }), p = u.chains.find((h) => h.id === i), w = await r.prepareTransactionRequest({
+        ...g(t),
+        chain: p
+      }), v = await T({
+        evmAccount: d,
+        transaction: {
+          ...w,
+          type: "eip1559"
+        }
+      });
+      return await r.sendRawTransaction({
+        serializedTransaction: v.signedTransaction
+      });
+    } catch (r) {
+      throw new o(
+        s.rpc.transactionRejected,
+        r instanceof Error ? r.message : "Transaction failed"
+      );
+    }
+}
+async function V(e) {
+  const [n, a] = e;
+  await m(a);
+  try {
+    return (await S({
+      evmAccount: a,
+      hash: n
+    })).signature;
+  } catch (t) {
+    throw new l(
+      s.provider.userRejectedRequest,
+      t instanceof Error ? t.message : "Signing failed"
+    );
+  }
+}
+async function W(e) {
+  return `0x${e.getState().chainId.toString(16)}`;
+}
+async function $() {
+  await f() && await P();
+}
+function K(e, n) {
+  const a = Number.parseInt(e[0].chainId, 16);
+  n.getState().setChainId(a);
 }
 export {
-  t as generateRandomId
+  M as handleAccounts,
+  W as handleChainId,
+  $ as handleDisconnect,
+  V as handleEthSign,
+  k as handlePersonalSign,
+  _ as handleRequestAccounts,
+  J as handleSendTransaction,
+  z as handleSignTypedData,
+  K as handleSwitchEthereumChain,
+  g as shimProviderTxRequest
 };

package/dist/esm/index24.js

@@ -1,7 +1,58 @@
-const h = async (t) => {
-  const a = await window.crypto.subtle.digest("SHA-256", t), r = new Uint8Array(a);
-  return Array.from(r).map((s) => s.toString(16).padStart(2, "0")).join("");
-};
+import { chainConfig as a } from "./index86.js";
+import { defineChain as t } from "./index25.js";
+const e = 11155111, r = /* @__PURE__ */ t({
+  ...a,
+  id: 84532,
+  network: "base-sepolia",
+  name: "Base Sepolia",
+  nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://sepolia.base.org"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Basescan",
+      url: "https://sepolia.basescan.org",
+      apiUrl: "https://api-sepolia.basescan.org/api"
+    }
+  },
+  contracts: {
+    ...a.contracts,
+    disputeGameFactory: {
+      [e]: {
+        address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
+      }
+    },
+    l2OutputOracle: {
+      [e]: {
+        address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
+      }
+    },
+    portal: {
+      [e]: {
+        address: "0x49f53e41452c74589e85ca1677426ba426459e85",
+        blockCreated: 4446677
+      }
+    },
+    l1StandardBridge: {
+      [e]: {
+        address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+        blockCreated: 4446677
+      }
+    },
+    multicall3: {
+      address: "0xca11bde05977b3631167028862be2a173976ca11",
+      blockCreated: 1059647
+    }
+  },
+  testnet: !0,
+  sourceId: e
+});
+({
+  ...r
+});
 export {
-  h as hash
+  r as baseSepolia
 };

package/dist/esm/index3.js

@@ -1,13 +1,13 @@
 import { Provider as h } from "ox";
 import { http as p } from "viem";
 import { create as l } from "zustand";
-import { subscribeWithSelector as f, persist as g } from "./index17.js";
+import { subscribeWithSelector as f, persist as g } from "./index21.js";
 import { validateRequest as w, EIP1193ProviderError as I, STANDARD_ERROR_CODES as S } from "./index4.js";
-import { EventEmitter as b } from "./index18.js";
+import { EventEmitter as b } from "./index22.js";
 import "@coinbase/cdp-api-client";
-import { handleChainId as A, handleSignTypedData as C, handleEthSign as _, handleSwitchEthereumChain as v, handleDisconnect as D, handleSendTransaction as E, handlePersonalSign as P, handleRequestAccounts as R, handleAccounts as y } from "./index19.js";
+import { handleChainId as A, handleSignTypedData as C, handleEthSign as _, handleSwitchEthereumChain as v, handleDisconnect as D, handleSendTransaction as E, handlePersonalSign as P, handleRequestAccounts as R, handleAccounts as y } from "./index23.js";
 import { onAuthStateChange as T } from "./index2.js";
-import { baseSepolia as d } from "./index20.js";
+import { baseSepolia as d } from "./index24.js";
 function q(r, e, a) {
   e.subscribe(
     (t) => t.chainId,

package/dist/esm/index6.js

@@ -1,10 +1,10 @@
 import { logOutEndUser as h, refreshAccessToken as l, registerTemporaryWalletSecret as c } from "@coinbase/cdp-api-client";
-import { SignJWT as o } from "./index21.js";
+import { SignJWT as o } from "./index17.js";
 import "viem";
 import { toAuthState as u } from "./index7.js";
-import { createKeyPair as S } from "./index22.js";
-import { generateRandomId as i } from "./index23.js";
-import { hash as w } from "./index24.js";
+import { createKeyPair as S } from "./index18.js";
+import { generateRandomId as i } from "./index19.js";
+import { hash as w } from "./index20.js";
 import { sortKeys as f } from "./index13.js";
 const n = 60 * 1e3;
 class C {

package/dist/esm/index77.js

@@ -1,4 +1,4 @@
-import { HashMD as D, SHA256_IV as b, Chi as g, Maj as p } from "./index86.js";
+import { HashMD as D, SHA256_IV as b, Chi as g, Maj as p } from "./index80.js";
 import { createHasher as u, clean as C, rotr as i } from "./index76.js";
 const B = /* @__PURE__ */ Uint32Array.from([
   1116352408,

package/dist/esm/index80.js

@@ -1,12 +1,81 @@
-import { contracts as o } from "./index88.js";
-import { formatters as r } from "./index89.js";
-import { serializers as t } from "./index90.js";
-const e = {
-  blockTime: 2e3,
-  contracts: o,
-  formatters: r,
-  serializers: t
-};
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index76.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 {
-  e as chainConfig
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
 };

package/dist/esm/index81.js

@@ -1,11 +1,11 @@
-import { encode as d } from "./index91.js";
-import y from "./index92.js";
-import b from "./index93.js";
+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 "./index82.js";
-import g from "./index94.js";
-import H from "./index95.js";
-import P from "./index96.js";
+import g from "./index91.js";
+import H from "./index92.js";
+import P from "./index93.js";
 class x {
   #r;
   #e;

package/dist/esm/index86.js

@@ -1,81 +1,12 @@
-import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index76.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
-]);
+import { contracts as o } from "./index94.js";
+import { formatters as r } from "./index95.js";
+import { serializers as t } from "./index96.js";
+const e = {
+  blockTime: 2e3,
+  contracts: o,
+  formatters: r,
+  serializers: t
+};
 export {
-  U as Chi,
-  m as HashMD,
-  _ as Maj,
-  B as SHA256_IV,
-  y as setBigUint64
+  e as chainConfig
 };

package/dist/esm/index88.js

@@ -1,15 +1,23 @@
-const s = {
-  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
-  l1Block: { address: "0x4200000000000000000000000000000000000015" },
-  l2CrossDomainMessenger: {
-    address: "0x4200000000000000000000000000000000000007"
-  },
-  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
-  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
-  l2ToL1MessagePasser: {
-    address: "0x4200000000000000000000000000000000000016"
+import { encoder as t, decoder as o } from "./index82.js";
+import { encodeBase64 as c, decodeBase64 as a } from "./index97.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 {
-  s as contracts
+  i as decode,
+  p as encode
 };

package/dist/esm/index89.js

@@ -1,38 +1,12 @@
-import { hexToBigInt as n } from "./index43.js";
-import { defineBlock as r } from "./index40.js";
-import { defineTransaction as s, formatTransaction as m } from "./index42.js";
-import { defineTransactionReceipt as l } from "./index45.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 n from "./index98.js";
+import s from "./index99.js";
+import a from "./index100.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 {
-  p as formatters
+  y as default
 };