@coinbase/cdp-core 0.0.45 → 0.0.47

package/dist/esm/index.native12.js

@@ -1,161 +1,121 @@
-import "ox";
-import "viem";
-import "zustand";
+import { Provider as h } from "ox";
+import { http as m } from "viem";
+import { createStore as p } from "zustand";
+import { subscribeWithSelector as g, persist as f, createJSONStorage as S } from "./index.native32.js";
+import { validateRequest as I, EIP1193ProviderError as w, STANDARD_ERROR_CODES as C } from "./index.native13.js";
+import { EventEmitter as b } from "./index.native33.js";
+import { getPlatformStorage as _ } from "./index.native6.js";
 import "@coinbase/cdp-api-client";
-import { getCurrentUser as h } from "./index.native6.js";
-import "./index.native11.js";
-const n = {
-  rpc: {
-    invalidInput: -32e3,
-    resourceNotFound: -32001,
-    resourceUnavailable: -32002,
-    transactionRejected: -32003,
-    methodNotSupported: -32004,
-    limitExceeded: -32005,
-    parse: -32700,
-    invalidRequest: -32600,
-    methodNotFound: -32601,
-    invalidParams: -32602,
-    internal: -32603
-  },
-  provider: {
-    userRejectedRequest: 4001,
-    unauthorized: 4100,
-    unsupportedMethod: 4200,
-    disconnected: 4900,
-    chainDisconnected: 4901,
-    unsupportedChain: 4902
-  }
-};
-class o extends Error {
-  /**
-   * The error code from EIP1193ErrorCode enum.
-   */
-  code;
-  /**
-   * Creates a new EIP-1193 Provider error.
-   *
-   * @param code - The error code from EIP1193ErrorCode enum.
-   * @param message - The error message.
-   */
-  constructor(t, r) {
-    super(r), this.code = t;
-  }
+import { handleGetCapabilities as A, handleGetCallsStatus as v, handleSendCalls as D, handleChainId as P, handleSignTypedData as E, handleEthSign as R, handleSwitchEthereumChain as y, handleDisconnect as T, handleSendTransaction as q, handlePersonalSign as N, handleRequestAccounts as O, handleAccounts as G } from "./index.native34.js";
+import { onAuthStateChange as L } from "./index.native7.js";
+import { baseSepolia as l } from "./index.native35.js";
+function M(r, n, s) {
+  n.subscribe(
+    (t) => t.chainId,
+    (t, e) => {
+      t !== e && r.emit("chainChanged", t);
+    }
+  ), n.subscribe(
+    (t) => t.user,
+    (t, e) => {
+      if (!(t?.userId === e?.userId && t?.evmAccounts?.length === e?.evmAccounts?.length)) {
+        if (!t && e) {
+          r.emit("disconnect", new h.DisconnectedError());
+          return;
+        }
+        if (t && t.evmAccounts?.length && (!e || e.evmAccounts?.length === 0)) {
+          const a = n.getState().chainId;
+          r.emit("connect", { chainId: a });
+          return;
+        }
+      }
+    }
+  );
+  const { chainId: i, setChainId: o } = n.getState(), d = i || s.chains[0].id;
+  return i || o(d), h.from({
+    request: async (t) => {
+      I(t, s);
+      const e = t;
+      switch (e.method) {
+        case "eth_accounts":
+          return G();
+        case "eth_requestAccounts":
+          return O(r, n);
+        case "personal_sign":
+          return N(e.params);
+        case "eth_sendTransaction":
+          return q(e.params, n, s.transports);
+        case "wallet_disconnect":
+          return T();
+        case "wallet_switchEthereumChain":
+          return y(e.params, n);
+        case "eth_sign":
+          return R(e.params);
+        case "eth_signTypedData_v4":
+          return E(e.params);
+        case "eth_chainId":
+          return P(n);
+        case "wallet_sendCalls":
+          return D(e.params, n);
+        case "wallet_getCallsStatus":
+          return v(e.params, n);
+        case "wallet_getCapabilities":
+          return A();
+        // Catch-all for any unknown method
+        default:
+          throw new w(
+            C.provider.unsupportedMethod,
+            `Method ${e.method} not supported`
+          );
+      }
+    },
+    // Event emitter methods - only the ones required by the interface
+    on: r.on.bind(r),
+    removeListener: r.removeListener.bind(r)
+  });
 }
-class c extends Error {
-  /**
-   * The error code from RPCErrorCode type.
-   */
-  code;
-  /**
-   * Creates a new RPC Invalid Params error.
-   *
-   * @param code - The error code from RPCErrorCode type.
-   * @param message - The error message.
-   */
-  constructor(t, r) {
-    super(r), this.code = t;
+const u = {
+  chains: [l],
+  transports: {
+    [l.id]: m()
   }
-}
-class p extends Error {
-  /**
-   * Creates a new AccountTypeMismatchError.
-   *
-   * @param message - The error message.
-   */
-  constructor(t) {
-    super(t);
-  }
-}
-const l = /* @__PURE__ */ new Set([
-  "eth_accounts",
-  "eth_requestAccounts",
-  "personal_sign",
-  "eth_sendTransaction",
-  "eth_signTypedData_v4",
-  "eth_chainId",
-  "eth_sign",
-  "wallet_disconnect",
-  "wallet_switchEthereumChain",
-  "wallet_sendCalls",
-  "wallet_getCallsStatus",
-  "wallet_getCapabilities"
-]);
-function _(e, { chains: t }) {
-  const { method: r, params: s } = e;
-  if (typeof r != "string" || r.length === 0)
-    throw new c(
-      n.rpc.invalidParams,
-      "'method' must be a non-empty string."
-    );
-  const a = (s ?? [])[0]?.chainId;
-  if (typeof a == "string" && !t.some((d) => d.id === Number.parseInt(a, 16)))
-    throw new o(
-      n.provider.unsupportedChain,
-      `Chain ${a} not supported - make sure the provider is configured with the correct chains.`
-    );
-  if (s !== void 0 && !Array.isArray(s))
-    throw new c(
-      n.rpc.invalidParams,
-      "'params' must be an array if provided."
-    );
-  if (!l.has(r))
-    throw new o(
-      n.provider.unsupportedMethod,
-      `Method ${e.method} not supported`
-    );
-}
-async function i() {
-  const e = await h();
-  if (!e)
-    throw new o(
-      n.provider.unauthorized,
-      "User not connected"
-    );
-  return e;
-}
-async function y(e) {
-  const t = await i();
-  if (!t.evmAccounts?.includes(e) && !t.evmSmartAccounts?.includes(e))
-    throw new o(
-      n.provider.unauthorized,
-      "Address not owned by user"
-    );
-  return t;
-}
-async function u() {
-  const e = await i();
-  if (!e.evmAccounts?.[0])
-    throw new o(
-      n.provider.unauthorized,
-      "No EVM accounts available"
-    );
-  return e;
-}
-async function g() {
-  const e = await i();
-  if (!e.evmSmartAccounts?.[0])
-    throw new o(
-      n.provider.unauthorized,
-      "No EVM smart accounts available"
-    );
-  return e;
-}
-async function S({ errorMessage: e } = {}) {
-  const t = await u();
-  if (await u(), !!t.evmSmartAccounts?.length)
-    throw new p(e ?? "Method unsupported.");
-  return t;
+};
+function Q(r) {
+  if (r?.chains.length === 0)
+    throw new Error("At least one chain must be configured");
+  const n = r?.chains ?? u.chains, s = r?.transports ?? u.transports;
+  if (n.length === 0)
+    throw new Error("No chains found in configuration");
+  const i = new b(), o = _(), d = {
+    getItem: (e) => o.getItem(e),
+    setItem: (e, a) => o.setItem(e, a),
+    removeItem: (e) => o.removeItem(e)
+  }, c = p()(
+    g(
+      f(
+        (e) => ({
+          chainId: n[0].id,
+          setChainId: (a) => e({ chainId: a }),
+          chains: n,
+          user: null,
+          setUser: (a) => e({ user: a })
+        }),
+        {
+          name: "cdp-provider-store",
+          storage: S(() => d)
+        }
+      )
+    )
+  );
+  return c.persist.rehydrate(), L((e) => {
+    c.getState().setUser(e);
+  }), {
+    provider: M(i, c, {
+      chains: n,
+      transports: s
+    })
+  };
 }
 export {
-  p as AccountTypeMismatchError,
-  o as EIP1193ProviderError,
-  c as RPCRequestError,
-  n as STANDARD_ERROR_CODES,
-  S as validateIsUsingEOA,
-  _ as validateRequest,
-  i as validateUserConnected,
-  u as validateUserHasEvmAccount,
-  g as validateUserHasEvmSmartAccount,
-  y as validateUserOwnsAddress
+  Q as createCDPEmbeddedWallet
 };

package/dist/esm/index.native120.js

@@ -0,0 +1,38 @@
+import { hexToBigInt as n } from "./index.native63.js";
+import { defineBlock as r } from "./index.native60.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.native62.js";
+import { defineTransactionReceipt as l } from "./index.native65.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
+      };
+    }
+  })
+};
+export {
+  p as formatters
+};

package/dist/esm/index.native121.js

@@ -0,0 +1,44 @@
+import { InvalidAddressError as a } from "./index.native78.js";
+import { isAddress as f } from "./index.native52.js";
+import { concatHex as p } from "./index.native53.js";
+import { toHex as i } from "./index.native47.js";
+import { toRlp as x } from "./index.native66.js";
+import { serializeTransaction as l } from "./index.native26.js";
+function T(r, e) {
+  return h(r) ? z(r) : l(r, e);
+}
+const E = {
+  transaction: T
+};
+function z(r) {
+  w(r);
+  const { sourceHash: e, data: o, from: m, gas: t, isSystemTx: u, mint: s, to: c, value: n } = r, d = [
+    e,
+    m,
+    c ?? "0x",
+    s ? i(s) : "0x",
+    n ? i(n) : "0x",
+    t ? i(t) : "0x",
+    u ? "0x1" : "0x",
+    o ?? "0x"
+  ];
+  return p([
+    "0x7e",
+    x(d)
+  ]);
+}
+function h(r) {
+  return r.type === "deposit" || typeof r.sourceHash < "u";
+}
+function w(r) {
+  const { from: e, to: o } = r;
+  if (e && !f(e))
+    throw new a({ address: e });
+  if (o && !f(o))
+    throw new a({ address: o });
+}
+export {
+  w as assertTransactionDeposit,
+  T as serializeTransaction,
+  E as serializers
+};

package/dist/esm/index.native122.js

@@ -0,0 +1,81 @@
+function r(t, e = "algorithm.name") {
+  return new TypeError(`CryptoKey does not support this operation, its ${e} must be ${t}`);
+}
+function o(t, e) {
+  return t.name === e;
+}
+function c(t) {
+  return parseInt(t.name.slice(4), 10);
+}
+function h(t) {
+  switch (t) {
+    case "ES256":
+      return "P-256";
+    case "ES384":
+      return "P-384";
+    case "ES512":
+      return "P-521";
+    default:
+      throw new Error("unreachable");
+  }
+}
+function i(t, e) {
+  if (!t.usages.includes(e))
+    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${e}.`);
+}
+function u(t, e, n) {
+  switch (e) {
+    case "HS256":
+    case "HS384":
+    case "HS512": {
+      if (!o(t.algorithm, "HMAC"))
+        throw r("HMAC");
+      const a = parseInt(e.slice(2), 10);
+      if (c(t.algorithm.hash) !== a)
+        throw r(`SHA-${a}`, "algorithm.hash");
+      break;
+    }
+    case "RS256":
+    case "RS384":
+    case "RS512": {
+      if (!o(t.algorithm, "RSASSA-PKCS1-v1_5"))
+        throw r("RSASSA-PKCS1-v1_5");
+      const a = parseInt(e.slice(2), 10);
+      if (c(t.algorithm.hash) !== a)
+        throw r(`SHA-${a}`, "algorithm.hash");
+      break;
+    }
+    case "PS256":
+    case "PS384":
+    case "PS512": {
+      if (!o(t.algorithm, "RSA-PSS"))
+        throw r("RSA-PSS");
+      const a = parseInt(e.slice(2), 10);
+      if (c(t.algorithm.hash) !== a)
+        throw r(`SHA-${a}`, "algorithm.hash");
+      break;
+    }
+    case "Ed25519":
+    case "EdDSA": {
+      if (!o(t.algorithm, "Ed25519"))
+        throw r("Ed25519");
+      break;
+    }
+    case "ES256":
+    case "ES384":
+    case "ES512": {
+      if (!o(t.algorithm, "ECDSA"))
+        throw r("ECDSA");
+      const a = h(e);
+      if (t.algorithm.namedCurve !== a)
+        throw r(a, "algorithm.namedCurve");
+      break;
+    }
+    default:
+      throw new TypeError("CryptoKey does not support this operation");
+  }
+  i(t, n);
+}
+export {
+  u as checkSigCryptoKey
+};