@coinbase/cdp-core 0.0.23 → 0.0.24

package/dist/esm/index94.js

@@ -1,96 +1,15 @@
-import { withAlg as n } from "./index101.js";
-import c from "./index102.js";
-import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index103.js";
-const s = (r) => r?.[Symbol.toStringTag], o = (r, e, t) => {
-  if (e.use !== void 0) {
-    let i;
-    switch (t) {
-      case "sign":
-      case "verify":
-        i = "sig";
-        break;
-      case "encrypt":
-      case "decrypt":
-        i = "enc";
-        break;
-    }
-    if (e.use !== i)
-      throw new TypeError(`Invalid key for this operation, its "use" must be "${i}" when present`);
+const s = {
+  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+  l1Block: { address: "0x4200000000000000000000000000000000000015" },
+  l2CrossDomainMessenger: {
+    address: "0x4200000000000000000000000000000000000007"
+  },
+  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+  l2ToL1MessagePasser: {
+    address: "0x4200000000000000000000000000000000000016"
   }
-  if (e.alg !== void 0 && e.alg !== r)
-    throw new TypeError(`Invalid key for this operation, its "alg" must be "${r}" when present`);
-  if (Array.isArray(e.key_ops)) {
-    let i;
-    switch (!0) {
-      case t === "sign":
-      case r === "dir":
-      case r.includes("CBC-HS"):
-        i = t;
-        break;
-      case r.startsWith("PBES2"):
-        i = "deriveBits";
-        break;
-      case /^A\d{3}(?:GCM)?(?:KW)?$/.test(r):
-        !r.includes("GCM") && r.endsWith("KW") ? i = "unwrapKey" : i = t;
-        break;
-      case t === "encrypt":
-        i = "wrapKey";
-        break;
-      case t === "decrypt":
-        i = r.startsWith("RSA") ? "unwrapKey" : "deriveBits";
-        break;
-    }
-    if (i && e.key_ops?.includes?.(i) === !1)
-      throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${i}" when present`);
-  }
-  return !0;
-}, h = (r, e, t) => {
-  if (!(e instanceof Uint8Array)) {
-    if (p(e)) {
-      if (a(e) && o(r, e, t))
-        return;
-      throw new TypeError('JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present');
-    }
-    if (!c(e))
-      throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array"));
-    if (e.type !== "secret")
-      throw new TypeError(`${s(e)} instances for symmetric algorithms must be of type "secret"`);
-  }
-}, m = (r, e, t) => {
-  if (p(e))
-    switch (t) {
-      case "decrypt":
-      case "sign":
-        if (f(e) && o(r, e, t))
-          return;
-        throw new TypeError("JSON Web Key for this operation be a private JWK");
-      case "encrypt":
-      case "verify":
-        if (y(e) && o(r, e, t))
-          return;
-        throw new TypeError("JSON Web Key for this operation be a public JWK");
-    }
-  if (!c(e))
-    throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key"));
-  if (e.type === "secret")
-    throw new TypeError(`${s(e)} instances for asymmetric algorithms must not be of type "secret"`);
-  if (e.type === "public")
-    switch (t) {
-      case "sign":
-        throw new TypeError(`${s(e)} instances for asymmetric algorithm signing must be of type "private"`);
-      case "decrypt":
-        throw new TypeError(`${s(e)} instances for asymmetric algorithm decryption must be of type "private"`);
-    }
-  if (e.type === "private")
-    switch (t) {
-      case "verify":
-        throw new TypeError(`${s(e)} instances for asymmetric algorithm verifying must be of type "public"`);
-      case "encrypt":
-        throw new TypeError(`${s(e)} instances for asymmetric algorithm encryption must be of type "public"`);
-    }
-}, d = (r, e, t) => {
-  r.startsWith("HS") || r === "dir" || r.startsWith("PBES2") || /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(r) || /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(r) ? h(r, e, t) : m(r, e, t);
 };
 export {
-  d as default
+  s as contracts
 };

package/dist/esm/index95.js

@@ -1,23 +1,38 @@
-import { JOSENotSupported as f } from "./index71.js";
-const w = (n, r, a, e, s) => {
-  if (s.crit !== void 0 && e?.crit === void 0)
-    throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');
-  if (!e || e.crit === void 0)
-    return /* @__PURE__ */ new Set();
-  if (!Array.isArray(e.crit) || e.crit.length === 0 || e.crit.some((i) => typeof i != "string" || i.length === 0))
-    throw new n('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-  let t;
-  a !== void 0 ? t = new Map([...Object.entries(a), ...r.entries()]) : t = r;
-  for (const i of e.crit) {
-    if (!t.has(i))
-      throw new f(`Extension Header Parameter "${i}" is not recognized`);
-    if (s[i] === void 0)
-      throw new n(`Extension Header Parameter "${i}" is missing`);
-    if (t.get(i) && e[i] === void 0)
-      throw new n(`Extension Header Parameter "${i}" MUST be integrity protected`);
-  }
-  return new Set(e.crit);
+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
+      };
+    }
+  })
 };
 export {
-  w as default
+  p as formatters
 };

package/dist/esm/index96.js

@@ -1,120 +1,44 @@
-import { isJWK as p } from "./index103.js";
-import { decode as m } from "./index91.js";
-import y from "./index104.js";
-import { isCryptoKey as S, isKeyObject as K } from "./index102.js";
-let c;
-const f = async (e, r, s, i = !1) => {
-  c ||= /* @__PURE__ */ new WeakMap();
-  let n = c.get(e);
-  if (n?.[s])
-    return n[s];
-  const t = await y({ ...r, alg: s });
-  return i && Object.freeze(e), n ? n[s] = t : c.set(e, { [s]: t }), t;
-}, E = (e, r) => {
-  c ||= /* @__PURE__ */ new WeakMap();
-  let s = c.get(e);
-  if (s?.[r])
-    return s[r];
-  const i = e.type === "public", n = !!i;
-  let t;
-  if (e.asymmetricKeyType === "x25519") {
-    switch (r) {
-      case "ECDH-ES":
-      case "ECDH-ES+A128KW":
-      case "ECDH-ES+A192KW":
-      case "ECDH-ES+A256KW":
-        break;
-      default:
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    }
-    t = e.toCryptoKey(e.asymmetricKeyType, n, i ? [] : ["deriveBits"]);
-  }
-  if (e.asymmetricKeyType === "ed25519") {
-    if (r !== "EdDSA" && r !== "Ed25519")
-      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    t = e.toCryptoKey(e.asymmetricKeyType, n, [
-      i ? "verify" : "sign"
-    ]);
-  }
-  if (e.asymmetricKeyType === "rsa") {
-    let a;
-    switch (r) {
-      case "RSA-OAEP":
-        a = "SHA-1";
-        break;
-      case "RS256":
-      case "PS256":
-      case "RSA-OAEP-256":
-        a = "SHA-256";
-        break;
-      case "RS384":
-      case "PS384":
-      case "RSA-OAEP-384":
-        a = "SHA-384";
-        break;
-      case "RS512":
-      case "PS512":
-      case "RSA-OAEP-512":
-        a = "SHA-512";
-        break;
-      default:
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    }
-    if (r.startsWith("RSA-OAEP"))
-      return e.toCryptoKey({
-        name: "RSA-OAEP",
-        hash: a
-      }, n, i ? ["encrypt"] : ["decrypt"]);
-    t = e.toCryptoKey({
-      name: r.startsWith("PS") ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
-      hash: a
-    }, n, [i ? "verify" : "sign"]);
-  }
-  if (e.asymmetricKeyType === "ec") {
-    const o = (/* @__PURE__ */ new Map([
-      ["prime256v1", "P-256"],
-      ["secp384r1", "P-384"],
-      ["secp521r1", "P-521"]
-    ])).get(e.asymmetricKeyDetails?.namedCurve);
-    if (!o)
-      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    r === "ES256" && o === "P-256" && (t = e.toCryptoKey({
-      name: "ECDSA",
-      namedCurve: o
-    }, n, [i ? "verify" : "sign"])), r === "ES384" && o === "P-384" && (t = e.toCryptoKey({
-      name: "ECDSA",
-      namedCurve: o
-    }, n, [i ? "verify" : "sign"])), r === "ES512" && o === "P-521" && (t = e.toCryptoKey({
-      name: "ECDSA",
-      namedCurve: o
-    }, n, [i ? "verify" : "sign"])), r.startsWith("ECDH-ES") && (t = e.toCryptoKey({
-      name: "ECDH",
-      namedCurve: o
-    }, n, i ? [] : ["deriveBits"]));
-  }
-  if (!t)
-    throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-  return s ? s[r] = t : c.set(e, { [r]: t }), t;
-}, d = async (e, r) => {
-  if (e instanceof Uint8Array || S(e))
-    return e;
-  if (K(e)) {
-    if (e.type === "secret")
-      return e.export();
-    if ("toCryptoKey" in e && typeof e.toCryptoKey == "function")
-      try {
-        return E(e, r);
-      } catch (i) {
-        if (i instanceof TypeError)
-          throw i;
-      }
-    let s = e.export({ format: "jwk" });
-    return f(e, s, r);
-  }
-  if (p(e))
-    return e.k ? m(e.k) : f(e, e, r, !0);
-  throw new Error("unreachable");
+import { InvalidAddressError as a } from "./index58.js";
+import { isAddress as f } from "./index32.js";
+import { concatHex as p } from "./index33.js";
+import { toHex as i } from "./index27.js";
+import { toRlp as x } from "./index46.js";
+import { serializeTransaction as l } from "./index15.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 {
-  d as default
+  w as assertTransactionDeposit,
+  T as serializeTransaction,
+  E as serializers
 };

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
 import { Address } from 'viem';
 import { APIError } from '@coinbase/cdp-api-client';
 import { APIErrorType } from '@coinbase/cdp-api-client';
+import { Call } from 'viem';
 import { Chain } from 'viem/chains';
 import { Chain as Chain_2 } from 'viem';
 import { ErrorType } from '@coinbase/cdp-api-client';
@@ -124,6 +125,16 @@ export declare type ExportEvmAccountResult = {
 
 export declare const getAccessToken: () => Promise<string | null>;
 
+export declare type GetCallsStatusRequest = {
+    method: "wallet_getCallsStatus";
+    params: [`0x${string}`];
+};
+
+export declare type GetCapabilitiesRequest = {
+    method: "wallet_getCapabilities";
+    params: [];
+};
+
 export declare const getCurrentUser: () => Promise<User | null>;
 
 export declare const getUserOperation: (options: GetUserOperationOptions) => Promise<GetUserOperationResult>;
@@ -153,7 +164,7 @@ export declare type PersonalSignRequest = {
     params: [`0x${string}`, `0x${string}`];
 };
 
-export declare type ProviderRequest = AccountsRequest | RequestAccountsRequest | PersonalSignRequest | SendTransactionRequest | SignTypedDataRequest | EthSignRequest | ChainIdRequest | WalletDisconnectRequest | SwitchEthereumChainRequest;
+export declare type ProviderRequest = AccountsRequest | RequestAccountsRequest | PersonalSignRequest | SendTransactionRequest | SignTypedDataRequest | EthSignRequest | ChainIdRequest | WalletDisconnectRequest | SwitchEthereumChainRequest | SendCallsRequest | GetCallsStatusRequest | GetCapabilitiesRequest;
 
 export declare type ProviderState = {
     chainId: number;
@@ -175,6 +186,13 @@ export declare type RequestAccountsRequest = {
 
 export declare type RPCErrorCode = (typeof STANDARD_ERROR_CODES)["rpc"][keyof (typeof STANDARD_ERROR_CODES)["rpc"]];
 
+export declare type SendCallsRequest = {
+    method: "wallet_sendCalls";
+    params: [{
+        calls: Call[];
+    }];
+};
+
 export declare const sendEvmTransaction: (options: SendEvmTransactionOptions) => Promise<SendEvmTransactionResult>;
 
 export declare type SendEvmTransactionOptions = {
@@ -372,6 +390,17 @@ export declare type VerifySmsOTPResult = {
     isNewUser: boolean;
 };
 
+export declare type WalletCapabilities = {
+    [chainId: Hex]: {
+        atomic: {
+            status: "supported" | "unsupported";
+        };
+        paymasterService: {
+            supported: boolean;
+        };
+    };
+};
+
 export declare type WalletDisconnectRequest = {
     method: "wallet_disconnect";
     params: [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-core",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "type": "module",
   "files": [
     "dist/**",
@@ -17,7 +17,7 @@
     "ox": "0.8.1",
     "viem": "^2.33.0",
     "zustand": "^5.0.6",
-    "@coinbase/cdp-api-client": "^0.0.23"
+    "@coinbase/cdp-api-client": "^0.0.24"
   },
   "devDependencies": {
     "@size-limit/preset-big-lib": "^11.2.0",