@coinbase/cdp-core 0.0.4 → 0.0.5

package/README.md

@@ -200,4 +200,56 @@ const { privateKey } = await exportEvmAccount({
 
 // WARNING: Handle private keys with extreme care!
 console.log("Private Key:", privateKey);
+```
+
+### EIP-1193 Provider
+
+The core package includes an EIP-1193 compatible provider. This provider can be used to sign and send transactions.
+
+The provider is created by calling `createCDPEmbeddedWallet`, which exposes a `.provider` attribute. `createCDPEmbeddedWallet` must be called with the desired chains to support as well as the transports for these chains. 
+
+The provider will initially connect to the first chain in the `chains` array. The transports are typically HTTP RPC endpoints, which are used internally for broadcasting non-Base transactions. For more information on transports, see [Wagmi's `createConfig` setup](https://wagmi.sh/react/api/createConfig).
+```typescript
+import { base, mainnet } from "viem/chains";
+import { http } from "viem"
+
+// Basic usage with default configuration
+const wallet = createCDPEmbeddedWallet({
+  chains:[base, mainnet],
+  transports: {
+    [base.id]: http(),
+    [mainnet.id]: http()
+  }
+});
+const provider = wallet.provider;
+
+// Request account access
+const accounts = await provider.request({
+  method: "eth_requestAccounts"
+});
+
+// Sign a message
+const signature = await provider.request({
+  method: "personal_sign",
+  params: ["Hello, World!", accounts[0]]
+});
+
+// Send a transaction
+const txHash = await provider.request({
+  method: "eth_sendTransaction",
+  params: [{
+    from: accounts[0],
+    to: "0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6",
+    value: "0x1000000000000000000"
+  }]
+});
+
+// Listen for connection events
+provider.on("connect", (connectInfo) => {
+  console.log("Connected to chain:", connectInfo.chainId);
+});
+
+provider.on("disconnect", () => {
+  console.log("Disconnected from wallet");
+});
 ```

package/dist/esm/index12.js

@@ -1,11 +1,18 @@
-import { SendEvmTransactionWithEndUserAccountBodyNetwork as s } from "@coinbase/cdp-api-client";
-const n = (r) => !r || typeof r != "object" ? r : Array.isArray(r) ? r.map(n) : Object.keys(r).sort().reduce(
-  (e, t) => (e[t] = n(r[t]), e),
+import { SendEvmTransactionWithEndUserAccountBodyNetwork as i } 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),
   {}
-), i = (r) => Object.values(s).includes(
-  r
-);
+), o = (e) => Object.values(i).includes(
+  e
+), s = {
+  "base-sepolia": 84532,
+  base: 8453
+}, c = Object.fromEntries(
+  Object.entries(s).map(([e, r]) => [r, e])
+), p = (e) => Object.values(s).includes(e);
 export {
-  i as isChainSupportedForCDPSends,
+  c as chainIdToNameMapping,
+  p as isChainIdSupportedForCDPSends,
+  o as isChainSupportedForCDPSends,
   n as sortKeys
 };

package/dist/esm/index16.js

@@ -1,107 +1,149 @@
-import { Provider as d, Hex as u } from "ox";
-import { signEvmTypedData as m, signEvmHash as h, getCurrentUser as c, signOut as g, sendEvmTransaction as l, signEvmMessage as v } from "./index2.js";
+import { Provider as y, Hex as I } from "ox";
+import { createWalletClient as E } from "viem";
+import { signEvmTypedData as S, signEvmHash as T, getCurrentUser as f, signOut as P, sendEvmTransaction as R, signEvmTransaction as A, signEvmMessage as x } from "./index2.js";
 import "./index3.js";
-import { validateUserOwnsAddress as o, EIP1193ProviderError as s, STANDARD_ERROR_CODES as i, validateUserHasEvmAccount as f, validateUserConnected as w } from "./index4.js";
-import { baseSepolia as p } from "./index17.js";
-async function P() {
-  return (await c())?.evmAccounts || [];
+import { validateUserOwnsAddress as m, EIP1193ProviderError as l, STANDARD_ERROR_CODES as s, RPCRequestError as c, validateUserHasEvmAccount as C, validateUserConnected as D } from "./index4.js";
+import { isChainIdSupportedForCDPSends as b, chainIdToNameMapping as j } from "./index12.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 R(t, e) {
-  const a = await w();
-  return t.emit("connect", {
-    chainId: u.fromNumber(e.getState().chainId)
-  }), a.evmAccounts;
+async function U() {
+  return (await f())?.evmAccounts || [];
 }
-async function D(t) {
-  const [e, a] = t;
-  await o(a);
+async function M(e, a) {
+  const n = await D();
+  return e.emit("connect", {
+    chainId: I.fromNumber(a.getState().chainId)
+  }), n.evmAccounts;
+}
+async function _(e) {
+  const [a, n] = e;
+  await m(n);
+  const t = Buffer.from(a.slice(2), "hex").toString();
   try {
-    return (await v({
-      evmAccount: a,
-      message: e
+    return (await x({
+      evmAccount: n,
+      message: t
     })).signature;
-  } catch (n) {
-    throw new s(
-      i.provider.userRejectedRequest,
-      n instanceof Error ? n.message : "Signing failed"
+  } catch (o) {
+    throw new l(
+      s.provider.userRejectedRequest,
+      o instanceof Error ? o.message : "Signing failed"
     );
   }
 }
-async function x(t) {
-  const [e, a] = t;
-  await o(a);
+async function k(e) {
+  const [a, n] = e;
+  await m(n);
   try {
-    const n = JSON.parse(e);
-    return (await m({
-      evmAccount: a,
-      typedData: n
+    const t = JSON.parse(a);
+    return (await S({
+      evmAccount: n,
+      typedData: t
     })).signature;
-  } catch (n) {
-    throw new s(
-      i.provider.userRejectedRequest,
-      n instanceof Error ? n.message : "Signing failed"
+  } catch (t) {
+    throw new l(
+      s.provider.userRejectedRequest,
+      t instanceof Error ? t.message : "Signing failed"
     );
   }
 }
-async function T(t) {
-  const [e] = t, n = (await f()).evmAccounts[0];
-  try {
-    return (await l({
-      evmAccount: n,
-      transaction: {
-        to: e.to,
-        value: BigInt(e.value),
-        data: e.data,
-        // Include data field for contract interactions
-        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,
-        chainId: e.chainId ? Number(e.chainId) : p.id,
-        type: "eip1559"
-      },
-      network: "base-sepolia"
-    })).transactionHash;
-  } catch (r) {
-    throw console.log("Transaction failed", r), new s(
-      i.provider.userRejectedRequest,
-      r instanceof Error ? r.message : "Transaction failed"
+async function z(e, a, n) {
+  const [t] = e;
+  if (!t || typeof t != "object")
+    throw new c(
+      s.rpc.invalidParams,
+      "Transaction parameter must be an object"
     );
-  }
+  if (!t.to)
+    throw new c(
+      s.rpc.invalidParams,
+      "Transaction must include 'to' field"
+    );
+  const d = (await C()).evmAccounts[0], u = a.getState(), i = t.chainId ? Number(t.chainId) : u.chainId;
+  if (b(i))
+    try {
+      return (await R({
+        evmAccount: d,
+        transaction: { ...g(t), chainId: i },
+        network: j[i]
+      })).transactionHash;
+    } catch (r) {
+      throw console.log("Transaction failed", r), new c(
+        s.rpc.transactionRejected,
+        r instanceof Error ? r.message : "Transaction failed"
+      );
+    }
+  else
+    try {
+      const r = E({
+        // Safe as we check before calling this handler that chainId is configured
+        chain: u.chains.find((h) => h.id === i),
+        transport: n[i],
+        account: d
+      }), p = u.chains.find((h) => h.id === i), w = await r.prepareTransactionRequest({
+        ...g(t),
+        chain: p
+      }), v = await A({
+        evmAccount: d,
+        transaction: {
+          ...w,
+          type: "eip1559"
+        }
+      });
+      return await r.sendRawTransaction({
+        serializedTransaction: v.signedTransaction
+      });
+    } catch (r) {
+      throw new c(
+        s.rpc.transactionRejected,
+        r instanceof Error ? r.message : "Transaction failed"
+      );
+    }
 }
-async function b(t) {
-  const [e, a] = t;
-  await o(a);
+async function J(e) {
+  const [a, n] = e;
+  await m(n);
   try {
-    return (await h({
-      evmAccount: a,
-      hash: e
+    return (await T({
+      evmAccount: n,
+      hash: a
     })).signature;
-  } catch (n) {
-    throw new s(
-      i.provider.userRejectedRequest,
-      n instanceof Error ? n.message : "Signing failed"
+  } catch (t) {
+    throw new l(
+      s.provider.userRejectedRequest,
+      t instanceof Error ? t.message : "Signing failed"
     );
   }
 }
-async function C(t) {
-  return `0x${t.getState().chainId.toString(16)}`;
+async function W(e) {
+  return `0x${e.getState().chainId.toString(16)}`;
 }
-async function F(t) {
-  await c() && await g(), t.emit("disconnect", new d.DisconnectedError());
+async function $(e) {
+  await f() && await P(), e.emit("disconnect", new y.DisconnectedError());
 }
-function G(t, e) {
-  const a = Number.parseInt(t[0].chainId, 16);
-  e.getState().setChainId(a);
+function K(e, a) {
+  const n = Number.parseInt(e[0].chainId, 16);
+  a.getState().setChainId(n);
 }
 export {
-  P as handleAccounts,
-  C as handleChainId,
-  F as handleDisconnect,
-  b as handleEthSign,
-  D as handlePersonalSign,
-  R as handleRequestAccounts,
-  T as handleSendTransaction,
-  x as handleSignTypedData,
-  G as handleSwitchEthereumChain
+  U as handleAccounts,
+  W as handleChainId,
+  $ as handleDisconnect,
+  J as handleEthSign,
+  _ as handlePersonalSign,
+  M as handleRequestAccounts,
+  z as handleSendTransaction,
+  k as handleSignTypedData,
+  K as handleSwitchEthereumChain,
+  g as shimProviderTxRequest
 };

package/dist/esm/index17.js

@@ -1,6 +1,6 @@
 import { chainConfig as a } from "./index77.js";
-import { defineChain as s } from "./index22.js";
-const e = 11155111, o = /* @__PURE__ */ s({
+import { defineChain as t } from "./index22.js";
+const e = 11155111, r = /* @__PURE__ */ t({
   ...a,
   id: 84532,
   network: "base-sepolia",
@@ -50,6 +50,9 @@ const e = 11155111, o = /* @__PURE__ */ s({
   testnet: !0,
   sourceId: e
 });
+({
+  ...r
+});
 export {
-  o as baseSepolia
+  r as baseSepolia
 };

package/dist/esm/index3.js

@@ -1,91 +1,92 @@
-import { Provider as u } from "ox";
-import { http as m } from "viem";
-import { create as l } from "zustand";
-import { subscribeWithSelector as p, persist as f } from "./index14.js";
-import { validateRequest as g, EIP1193ProviderError as I, STANDARD_ERROR_CODES as S } from "./index4.js";
-import { EventEmitter as w } from "./index15.js";
-import { handleChainId as b, handleSignTypedData as A, handleEthSign as _, handleSwitchEthereumChain as C, handleDisconnect as v, handleSendTransaction as D, handlePersonalSign as P, handleRequestAccounts as R, handleAccounts as E } from "./index16.js";
-import { onAuthStateChange as T } from "./index2.js";
+import { Provider as m } from "ox";
+import { http as l } from "viem";
+import { create as p } from "zustand";
+import { subscribeWithSelector as f, persist as g } from "./index14.js";
+import { validateRequest as I, EIP1193ProviderError as S, STANDARD_ERROR_CODES as w } from "./index4.js";
+import { EventEmitter as b } from "./index15.js";
+import { handleChainId as A, handleSignTypedData as C, handleEthSign as _, handleSwitchEthereumChain as v, handleDisconnect as D, handleSendTransaction as P, handlePersonalSign as R, handleRequestAccounts as E, handleAccounts as T } from "./index16.js";
+import { onAuthStateChange as q } from "./index2.js";
 import { baseSepolia as h } from "./index17.js";
-function q(t, r, c) {
+function y(e, r, a) {
   r.subscribe(
-    (e) => e.chainId,
-    (e, n) => {
-      e !== n && t.emit("chainChanged", e);
+    (n) => n.chainId,
+    (n, t) => {
+      n !== t && e.emit("chainChanged", n);
     }
   ), r.subscribe(
-    (e) => e.user,
-    (e, n) => {
-      if (!(e?.userId === n?.userId && e?.evmAccounts?.length === n?.evmAccounts?.length)) {
-        if (!e && n) {
-          t.emit("disconnect");
+    (n) => n.user,
+    (n, t) => {
+      if (!(n?.userId === t?.userId && n?.evmAccounts?.length === t?.evmAccounts?.length)) {
+        if (!n && t) {
+          e.emit("disconnect");
           return;
         }
-        if (e && e.evmAccounts?.length && (!n || n.evmAccounts?.length === 0)) {
-          const d = r.getState().chainId;
-          t.emit("connect", { chainId: d });
+        if (n && n.evmAccounts?.length && (!t || t.evmAccounts?.length === 0)) {
+          const u = r.getState().chainId;
+          e.emit("connect", { chainId: u });
           return;
         }
       }
     }
   );
-  const { chainId: o, setChainId: s } = r.getState(), a = o || c.chains[0].id;
-  return o || s(a), u.from({
-    request: async (e) => {
-      g(e, c);
-      const n = e;
-      switch (n.method) {
+  const { chainId: s, setChainId: i } = r.getState(), c = s || a.chains[0].id;
+  return s || i(c), m.from({
+    request: async (n) => {
+      I(n, a);
+      const t = n;
+      switch (t.method) {
         case "eth_accounts":
-          return E();
+          return T();
         case "eth_requestAccounts":
-          return R(t, r);
+          return E(e, r);
         case "personal_sign":
-          return P(n.params);
+          return R(t.params);
         case "eth_sendTransaction":
-          return D(n.params);
+          return P(t.params, r, a.transports);
         case "wallet_disconnect":
-          return v(t);
+          return D(e);
         case "wallet_switchEthereumChain":
-          return C(n.params, r);
+          return v(t.params, r);
         case "eth_sign":
-          return _(n.params);
+          return _(t.params);
         case "eth_signTypedData_v4":
-          return A(n.params);
+          return C(t.params);
         case "eth_chainId":
-          return b(r);
+          return A(r);
         // Catch-all for any unknown method
         default:
-          throw new I(
-            S.provider.unsupportedMethod,
-            `Method ${n.method} not supported`
+          throw new S(
+            w.provider.unsupportedMethod,
+            `Method ${t.method} not supported`
           );
       }
     },
     // Event emitter methods - only the ones required by the interface
-    on: t.on.bind(t),
-    removeListener: t.removeListener.bind(t)
+    on: e.on.bind(e),
+    removeListener: e.removeListener.bind(e)
   });
 }
-const y = {
+const d = {
   chains: [h],
   transports: {
-    [h.id]: m()
+    [h.id]: l()
   }
 };
-function z(t) {
-  if (t?.chains.length === 0)
+function z(e) {
+  if (e?.chains.length === 0)
     throw new Error("At least one chain must be configured");
-  const r = t?.chains ?? y.chains;
+  const r = e?.chains ?? d.chains, a = e?.transports ?? d.transports;
   if (r.length === 0)
     throw new Error("No chains found in configuration");
-  const c = new w(), o = l()(
-    p(
-      f(
-        (a) => ({
+  const s = new b(), i = p()(
+    f(
+      g(
+        (o) => ({
           chainId: r[0].id,
-          setChainId: (i) => a({ chainId: i }),
+          setChainId: (n) => o({ chainId: n }),
+          chains: r,
           user: null,
-          setUser: (i) => a({ user: i })
+          setUser: (n) => o({ user: n })
         }),
         {
           name: "cdp-provider-store"
@@ -94,11 +95,12 @@ function z(t) {
       )
     )
   );
-  return T((a) => {
-    o.getState().setUser(a);
+  return q((o) => {
+    i.getState().setUser(o);
   }), {
-    provider: q(c, o, {
-      chains: r
+    provider: y(s, i, {
+      chains: r,
+      transports: a
     })
   };
 }

package/dist/esm/index4.js

@@ -117,7 +117,7 @@ async function w() {
 }
 export {
   o as EIP1193ProviderError,
-  a as RPCInvalidParamsError,
+  a as RPCRequestError,
   n as STANDARD_ERROR_CODES,
   l as validateRequest,
   d as validateUserConnected,

package/dist/esm/index70.js

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

package/dist/types/index.d.ts

@@ -114,6 +114,7 @@ export declare type ProviderRequest = AccountsRequest | RequestAccountsRequest |
 export declare type ProviderState = {
     chainId: number;
     setChainId: (chainId: number) => void;
+    chains: readonly [Chain_2, ...Chain_2[]];
     user: User | null;
     setUser: (user: User | null) => void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-core",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "module",
   "files": [
     "dist/**",
@@ -15,9 +15,9 @@
   "dependencies": {
     "jose": "^6.0.11",
     "ox": "0.8.1",
-    "viem": "2.31.3",
+    "viem": "^2.33.0",
     "zustand": "^5.0.6",
-    "@coinbase/cdp-api-client": "^0.0.4"
+    "@coinbase/cdp-api-client": "^0.0.5"
   },
   "devDependencies": {
     "@size-limit/preset-big-lib": "^11.2.0",
@@ -30,7 +30,7 @@
       "name": "full-package",
       "path": "./dist/esm/index.js",
       "import": "*",
-      "limit": "40 KB"
+      "limit": "60 KB"
     },
     {
       "name": "auth-only",
@@ -54,7 +54,7 @@
       "name": "provider-only",
       "path": "./dist/esm/index.js",
       "import": "{ createCDPEmbeddedWallet }",
-      "limit": "35 KB"
+      "limit": "55 KB"
     }
   ],
   "scripts": {