@coinbase/cdp-core 0.0.18 → 0.0.20

package/README.md

@@ -93,7 +93,15 @@ if (signedIn) {
 ```
 
 ### Send a Transaction
-We support signing and sending a Blockchain transaction in a single call on Base or Base Sepolia:
+We support signing and sending a Blockchain transaction in a single call on the following networks:
+- Base
+- Base Sepolia
+- Ethereum
+- Ethereum Sepolia
+- Avalanche
+- Arbitrum
+- Optimism
+- Polygon
 
 ```typescript
 import { sendEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
@@ -118,13 +126,13 @@ const result = await sendEvmTransaction({
 console.log("Transaction Hash:", result.transactionHash);
 ```
 
-For networks other than Base or Base Sepolia, your end user must sign the transaction, and then
+For networks other than those supported by the CDP APIs, your end user must sign the transaction, and then
 you must broadcast the transaction yourself. This example uses the public client from `viem` to broadcast the transaction. 
 
 ```typescript
 import { signEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
 import { http, createPublicClient } from "viem";
-import { sepolia } from "viem/chains";
+import { tron } from "viem/chains";
 
 const user = await getCurrentUser();
 const evmAccount = user.evmAccounts[0];
@@ -139,14 +147,14 @@ const { signedTransaction } = await signEvmTransaction({
     gas: 21000n,
     maxFeePerGas: 30000000000n,
     maxPriorityFeePerGas: 1000000000n,
-    chainId: 11155111, // Sepolia
+    chainId: 728126428, // Tron
     type: "eip1559",
   }
 });
 
 // Broadcast signed transaction to non-Base chain
 const client = createPublicClient({
-  chain: sepolia,
+  chain: tron,
   transport: http()
 });
 

package/dist/esm/index.js

@@ -1,31 +1,34 @@
-import { exportEvmAccount as n, getCurrentUser as m, initialize as E, isSignedIn as a, onAuthStateChange as s, sendEvmTransaction as p, signEvmHash as c, signEvmMessage as d, signEvmTransaction as g, signEvmTypedData as v, signInWithEmail as T, signOut as A, verifyEmailOTP as f } from "./index2.js";
-import { APIError as x, ErrorType as h, HttpErrorType as l, SendEvmTransactionWithEndUserAccountBodyNetwork as y } from "@coinbase/cdp-api-client";
+import { exportEvmAccount as n, getAccessToken as m, getCurrentUser as s, initialize as E, isSignedIn as a, onAuthStateChange as p, sendEvmTransaction as c, signEvmHash as g, signEvmMessage as d, signEvmTransaction as v, signEvmTypedData as T, signInWithEmail as A, signInWithSms as f, signOut as S, verifyEmailOTP as h, verifySmsOTP as u } from "./index2.js";
+import { APIError as y, ErrorType as P, HttpErrorType as l, SendEvmTransactionWithEndUserAccountBodyNetwork as D } from "@coinbase/cdp-api-client";
 import "viem";
-import { createCDPEmbeddedWallet as P } from "./index3.js";
-import { EIP1193ProviderError as C, STANDARD_ERROR_CODES as I } from "./index4.js";
+import { createCDPEmbeddedWallet as O } from "./index3.js";
+import { EIP1193ProviderError as R, STANDARD_ERROR_CODES as W } from "./index4.js";
 import "ox";
 import "zustand";
-import { toViemAccount as R } from "./index5.js";
+import { toViemAccount as H } from "./index5.js";
 export {
-  x as APIError,
-  C as EIP1193ProviderError,
-  h as ErrorType,
+  y as APIError,
+  R as EIP1193ProviderError,
+  P as ErrorType,
   l as HttpErrorType,
-  I as STANDARD_ERROR_CODES,
-  y as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  P as createCDPEmbeddedWallet,
+  W as STANDARD_ERROR_CODES,
+  D as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  O as createCDPEmbeddedWallet,
   n as exportEvmAccount,
-  m as getCurrentUser,
+  m as getAccessToken,
+  s as getCurrentUser,
   E as initialize,
   a as isSignedIn,
-  s as onAuthStateChange,
-  p as sendEvmTransaction,
-  c as signEvmHash,
+  p as onAuthStateChange,
+  c as sendEvmTransaction,
+  g as signEvmHash,
   d as signEvmMessage,
-  g as signEvmTransaction,
-  v as signEvmTypedData,
-  T as signInWithEmail,
-  A as signOut,
-  R as toViemAccount,
-  f as verifyEmailOTP
+  v as signEvmTransaction,
+  T as signEvmTypedData,
+  A as signInWithEmail,
+  f as signInWithSms,
+  S as signOut,
+  H as toViemAccount,
+  h as verifyEmailOTP,
+  u as verifySmsOTP
 };

package/dist/esm/index103.js

@@ -1,4 +1,4 @@
-import n from "./index85.js";
+import n from "./index86.js";
 function r(t) {
   return n(t) && typeof t.kty == "string";
 }

package/dist/esm/index13.js

@@ -1,12 +1,18 @@
-import { SendEvmTransactionWithEndUserAccountBodyNetwork as i } from "@coinbase/cdp-api-client";
+import { SendEvmTransactionWithEndUserAccountBodyNetwork as a } from "@coinbase/cdp-api-client";
 const n = (e) => !e || typeof e != "object" ? e : Array.isArray(e) ? e.map(n) : Object.keys(e).sort().reduce(
   (r, t) => (r[t] = n(e[t]), r),
   {}
-), o = (e) => Object.values(i).includes(
+), o = (e) => Object.values(a).includes(
   e
 ), s = {
   "base-sepolia": 84532,
-  base: 8453
+  base: 8453,
+  ethereum: 1,
+  "ethereum-sepolia": 11155111,
+  avalanche: 43114,
+  polygon: 137,
+  optimism: 10,
+  arbitrum: 42161
 }, c = Object.fromEntries(
   Object.entries(s).map(([e, r]) => [r, e])
 ), p = (e) => Object.values(s).includes(e);

package/dist/esm/index15.js

@@ -1,15 +1,15 @@
-import { InvalidLegacyVError as H } from "./index54.js";
-import { serializeAuthorizationList as g } from "./index26.js";
+import { InvalidLegacyVError as H } from "./index55.js";
+import { serializeAuthorizationList as g } from "./index28.js";
 import { blobsToCommitments as B } from "./index62.js";
 import { blobsToProofs as V } from "./index63.js";
 import { commitmentsToVersionedHashes as C } from "./index64.js";
 import { toBlobSidecars as k } from "./index65.js";
-import { concatHex as h } from "./index33.js";
-import { trim as T } from "./index39.js";
-import { numberToHex as o, bytesToHex as w } from "./index27.js";
-import { toRlp as b } from "./index46.js";
-import { assertTransactionEIP1559 as S, assertTransactionEIP2930 as _, assertTransactionEIP4844 as R, assertTransactionEIP7702 as Y, assertTransactionLegacy as j } from "./index55.js";
-import { getTransactionType as q } from "./index53.js";
+import { concatHex as h } from "./index34.js";
+import { trim as T } from "./index40.js";
+import { numberToHex as o, bytesToHex as w } from "./index29.js";
+import { toRlp as b } from "./index47.js";
+import { assertTransactionEIP1559 as S, assertTransactionEIP2930 as _, assertTransactionEIP4844 as R, assertTransactionEIP7702 as Y, assertTransactionLegacy as j } from "./index56.js";
+import { getTransactionType as q } from "./index54.js";
 import { serializeAccessList as v } from "./index66.js";
 function te(e, r) {
   const i = q(e);

package/dist/esm/index16.js

@@ -1,5 +1,5 @@
-import { InvalidAddressError as s } from "./index58.js";
-import { isAddress as a } from "./index32.js";
+import { InvalidAddressError as s } from "./index25.js";
+import { isAddress as a } from "./index26.js";
 function r(n) {
   if (typeof n == "string") {
     if (!a(n, { strict: !1 }))

package/dist/esm/index17.js

@@ -1,43 +1,162 @@
-import { CompactSign as i } from "./index70.js";
-import { JWTInvalid as r } from "./index71.js";
-import { JWTClaimsBuilder as n } from "./index72.js";
-class d {
-  #s;
-  #t;
-  constructor(t = {}) {
-    this.#t = new n(t);
-  }
-  setIssuer(t) {
-    return this.#t.iss = t, this;
-  }
-  setSubject(t) {
-    return this.#t.sub = t, this;
-  }
-  setAudience(t) {
-    return this.#t.aud = t, this;
-  }
-  setJti(t) {
-    return this.#t.jti = t, this;
-  }
-  setNotBefore(t) {
-    return this.#t.nbf = t, this;
-  }
-  setExpirationTime(t) {
-    return this.#t.exp = t, this;
-  }
-  setIssuedAt(t) {
-    return this.#t.iat = t, this;
-  }
-  setProtectedHeader(t) {
-    return this.#s = t, this;
-  }
-  async sign(t, e) {
-    const s = new i(this.#t.data());
-    if (s.setProtectedHeader(this.#s), Array.isArray(this.#s?.crit) && this.#s.crit.includes("b64") && this.#s.b64 === !1)
-      throw new r("JWTs MUST NOT use unencoded payload");
-    return s.sign(t, e);
+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 {
-  d as SignJWT
+  F as createJSONStorage,
+  w as persist,
+  R as subscribeWithSelector
 };

package/dist/esm/index18.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/index19.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
 };