@coinbase/cdp-core 0.0.49 → 0.0.50

package/dist/native/index.native132.js

@@ -0,0 +1,83 @@
+import { JOSENotSupported as s } from "./index.native43.js";
+function n(e) {
+  let a, r;
+  switch (e.kty) {
+    case "RSA": {
+      switch (e.alg) {
+        case "PS256":
+        case "PS384":
+        case "PS512":
+          a = { name: "RSA-PSS", hash: `SHA-${e.alg.slice(-3)}` }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "RS256":
+        case "RS384":
+        case "RS512":
+          a = { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${e.alg.slice(-3)}` }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "RSA-OAEP":
+        case "RSA-OAEP-256":
+        case "RSA-OAEP-384":
+        case "RSA-OAEP-512":
+          a = {
+            name: "RSA-OAEP",
+            hash: `SHA-${parseInt(e.alg.slice(-3), 10) || 1}`
+          }, r = e.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    case "EC": {
+      switch (e.alg) {
+        case "ES256":
+          a = { name: "ECDSA", namedCurve: "P-256" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ES384":
+          a = { name: "ECDSA", namedCurve: "P-384" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ES512":
+          a = { name: "ECDSA", namedCurve: "P-521" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ECDH-ES":
+        case "ECDH-ES+A128KW":
+        case "ECDH-ES+A192KW":
+        case "ECDH-ES+A256KW":
+          a = { name: "ECDH", namedCurve: e.crv }, r = e.d ? ["deriveBits"] : [];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    case "OKP": {
+      switch (e.alg) {
+        case "Ed25519":
+        case "EdDSA":
+          a = { name: "Ed25519" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ECDH-ES":
+        case "ECDH-ES+A128KW":
+        case "ECDH-ES+A192KW":
+        case "ECDH-ES+A256KW":
+          a = { name: e.crv }, r = e.d ? ["deriveBits"] : [];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    default:
+      throw new s('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
+  }
+  return { algorithm: a, keyUsages: r };
+}
+const i = async (e) => {
+  if (!e.alg)
+    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
+  const { algorithm: a, keyUsages: r } = n(e), t = { ...e };
+  return delete t.alg, delete t.use, crypto.subtle.importKey("jwk", t, a, e.ext ?? !e.d, e.key_ops ?? r);
+};
+export {
+  i as default
+};

package/dist/native/index.native133.js

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

package/dist/native/index.native134.js

@@ -0,0 +1,111 @@
+import { __module as x } from "./index.native135.js";
+var w;
+function O() {
+  return w ? x.exports : (w = 1, function(d) {
+    var g = Object.prototype.hasOwnProperty, c = "~";
+    function h() {
+    }
+    Object.create && (h.prototype = /* @__PURE__ */ Object.create(null), new h().__proto__ || (c = !1));
+    function b(s, t, n) {
+      this.fn = s, this.context = t, this.once = n || !1;
+    }
+    function m(s, t, n, r, l) {
+      if (typeof n != "function")
+        throw new TypeError("The listener must be a function");
+      var u = new b(n, r || s, l), o = c ? c + t : t;
+      return s._events[o] ? s._events[o].fn ? s._events[o] = [s._events[o], u] : s._events[o].push(u) : (s._events[o] = u, s._eventsCount++), s;
+    }
+    function y(s, t) {
+      --s._eventsCount === 0 ? s._events = new h() : delete s._events[t];
+    }
+    function f() {
+      this._events = new h(), this._eventsCount = 0;
+    }
+    f.prototype.eventNames = function() {
+      var t = [], n, r;
+      if (this._eventsCount === 0) return t;
+      for (r in n = this._events)
+        g.call(n, r) && t.push(c ? r.slice(1) : r);
+      return Object.getOwnPropertySymbols ? t.concat(Object.getOwnPropertySymbols(n)) : t;
+    }, f.prototype.listeners = function(t) {
+      var n = c ? c + t : t, r = this._events[n];
+      if (!r) return [];
+      if (r.fn) return [r.fn];
+      for (var l = 0, u = r.length, o = new Array(u); l < u; l++)
+        o[l] = r[l].fn;
+      return o;
+    }, f.prototype.listenerCount = function(t) {
+      var n = c ? c + t : t, r = this._events[n];
+      return r ? r.fn ? 1 : r.length : 0;
+    }, f.prototype.emit = function(t, n, r, l, u, o) {
+      var a = c ? c + t : t;
+      if (!this._events[a]) return !1;
+      var e = this._events[a], p = arguments.length, v, i;
+      if (e.fn) {
+        switch (e.once && this.removeListener(t, e.fn, void 0, !0), p) {
+          case 1:
+            return e.fn.call(e.context), !0;
+          case 2:
+            return e.fn.call(e.context, n), !0;
+          case 3:
+            return e.fn.call(e.context, n, r), !0;
+          case 4:
+            return e.fn.call(e.context, n, r, l), !0;
+          case 5:
+            return e.fn.call(e.context, n, r, l, u), !0;
+          case 6:
+            return e.fn.call(e.context, n, r, l, u, o), !0;
+        }
+        for (i = 1, v = new Array(p - 1); i < p; i++)
+          v[i - 1] = arguments[i];
+        e.fn.apply(e.context, v);
+      } else {
+        var E = e.length, _;
+        for (i = 0; i < E; i++)
+          switch (e[i].once && this.removeListener(t, e[i].fn, void 0, !0), p) {
+            case 1:
+              e[i].fn.call(e[i].context);
+              break;
+            case 2:
+              e[i].fn.call(e[i].context, n);
+              break;
+            case 3:
+              e[i].fn.call(e[i].context, n, r);
+              break;
+            case 4:
+              e[i].fn.call(e[i].context, n, r, l);
+              break;
+            default:
+              if (!v) for (_ = 1, v = new Array(p - 1); _ < p; _++)
+                v[_ - 1] = arguments[_];
+              e[i].fn.apply(e[i].context, v);
+          }
+      }
+      return !0;
+    }, f.prototype.on = function(t, n, r) {
+      return m(this, t, n, r, !1);
+    }, f.prototype.once = function(t, n, r) {
+      return m(this, t, n, r, !0);
+    }, f.prototype.removeListener = function(t, n, r, l) {
+      var u = c ? c + t : t;
+      if (!this._events[u]) return this;
+      if (!n)
+        return y(this, u), this;
+      var o = this._events[u];
+      if (o.fn)
+        o.fn === n && (!l || o.once) && (!r || o.context === r) && y(this, u);
+      else {
+        for (var a = 0, e = [], p = o.length; a < p; a++)
+          (o[a].fn !== n || l && !o[a].once || r && o[a].context !== r) && e.push(o[a]);
+        e.length ? this._events[u] = e.length === 1 ? e[0] : e : y(this, u);
+      }
+      return this;
+    }, f.prototype.removeAllListeners = function(t) {
+      var n;
+      return t ? (n = c ? c + t : t, this._events[n] && y(this, n)) : (this._events = new h(), this._eventsCount = 0), this;
+    }, f.prototype.off = f.prototype.removeListener, f.prototype.addListener = f.prototype.on, f.prefixed = c, f.EventEmitter = f, d.exports = f;
+  }(x), x.exports);
+}
+export {
+  O as __require
+};

package/dist/native/index.native135.js

@@ -0,0 +1,4 @@
+var e = { exports: {} };
+export {
+  e as __module
+};

package/dist/native/index.native136.js

@@ -0,0 +1,15 @@
+const s = {
+  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+  l1Block: { address: "0x4200000000000000000000000000000000000015" },
+  l2CrossDomainMessenger: {
+    address: "0x4200000000000000000000000000000000000007"
+  },
+  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+  l2ToL1MessagePasser: {
+    address: "0x4200000000000000000000000000000000000016"
+  }
+};
+export {
+  s as contracts
+};

package/dist/native/index.native137.js

@@ -0,0 +1,38 @@
+import { hexToBigInt as n } from "./index.native65.js";
+import { defineBlock as r } from "./index.native62.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.native64.js";
+import { defineTransactionReceipt as l } from "./index.native67.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/native/index.native138.js

@@ -0,0 +1,44 @@
+import { InvalidAddressError as a } from "./index.native80.js";
+import { isAddress as f } from "./index.native54.js";
+import { concatHex as p } from "./index.native55.js";
+import { toHex as i } from "./index.native49.js";
+import { toRlp as x } from "./index.native68.js";
+import { serializeTransaction as l } from "./index.native27.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/native/index.native139.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
+};

package/dist/native/index.native14.js

@@ -1,9 +1,9 @@
 import { serializeErc6492Signature as i, encodeFunctionData as c, pad as u, getTypesForEIP712Domain as m } from "viem";
 import { getCurrentUser as g, signEvmHash as A, signEvmTypedData as l, signEvmTransaction as d, signEvmMessage as f } from "./index.native7.js";
 import "@coinbase/cdp-api-client";
-import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as y, COINBASE_SMART_WALLET_FACTORY_ABI as p } from "./index.native29.js";
-import { signAndWrapTypedDataForSmartAccount as v } from "./index.native30.js";
-import { toAccount as w } from "./index.native31.js";
+import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as y, COINBASE_SMART_WALLET_FACTORY_ABI as p } from "./index.native30.js";
+import { signAndWrapTypedDataForSmartAccount as v } from "./index.native31.js";
+import { toAccount as w } from "./index.native32.js";
 async function F(n) {
   const r = await g();
   if (!r || !r.evmAccounts?.length && !r.evmSmartAccounts?.length)

package/dist/native/index.native17.js

@@ -1,4 +1,4 @@
-import { __require as r } from "./index.native32.js";
+import { __require as r } from "./index.native33.js";
 var f = r();
 export {
   f as b

package/dist/native/index.native18.js

@@ -1,87 +1,2 @@
-import { verifyOAuth as u } from "./index.native7.js";
-import { getPlatformOAuth as s } from "./index.native6.js";
-import { getCoreAuthManager as i } from "./index.native25.js";
-import "@coinbase/cdp-api-client";
-import "viem";
-class p {
-  oauthFlowState = null;
-  oauthStateChangeCallbacks = [];
-  /**
-   * Adds a callback to be called when the OAuth state changes.
-   *
-   * @param callback - The function to call when the OAuth state changes.
-   */
-  async addOAuthStateChangeCallback(t) {
-    this.oauthStateChangeCallbacks.push(t), t(this.oauthFlowState);
-  }
-  /**
-   * Sets the OAuth flow state.
-   *
-   * @param oauthFlowState - The OAuth flow state.
-   */
-  async setOAuthFlowState(t) {
-    this.oauthFlowState = t, this.oauthStateChangeCallbacks.forEach((a) => a(this.oauthFlowState));
-  }
-  /**
-   * Clears the OAuth flow state.
-   */
-  async clearOAuthFlowState() {
-    this.oauthFlowState = null, this.oauthStateChangeCallbacks.forEach((t) => t(null));
-  }
-  /**
-   * Gets the OAuth flow state.
-   *
-   * @returns The OAuth flow state.
-   */
-  async getOAuthFlowState() {
-    return this.oauthFlowState;
-  }
-  /**
-   * Handles the OAuth code.
-   */
-  async handleOAuthCode() {
-    try {
-      const t = await s().getOAuthParams();
-      if (await s().cleanupOAuthParams(), !t || await i().isSignedIn())
-        return;
-      const { providerType: a, code: e, flowId: r, error: o, errorDescription: h } = t;
-      if (o || h) {
-        await this.setOAuthFlowState({
-          providerType: a,
-          status: "error",
-          errorDescription: o ?? h,
-          code: e,
-          flowId: r,
-          error: o
-        });
-        return;
-      }
-      if (!e || !a || !r)
-        return;
-      await this.setOAuthFlowState({
-        providerType: a,
-        status: "pending",
-        code: e,
-        flowId: r
-      }), await u({
-        code: e,
-        providerType: a,
-        flowId: r
-      }), await this.setOAuthFlowState({
-        providerType: a,
-        status: "success",
-        code: e,
-        flowId: r
-      });
-    } catch (t) {
-      const a = t instanceof Error ? t.message : "Unknown error";
-      await s().cleanupOAuthParams(), await this.setOAuthFlowState({
-        status: "error",
-        errorDescription: a
-      });
-    }
-  }
-}
-export {
-  p as OAuthManager
-};
+import { __require as r } from "./index.native103.js";
+r();

package/dist/native/index.native19.js

@@ -1,18 +1,87 @@
+import { verifyOAuth as u } from "./index.native7.js";
+import { getPlatformOAuth as s } from "./index.native6.js";
+import { getCoreAuthManager as i } from "./index.native26.js";
 import "@coinbase/cdp-api-client";
-const m = (c, a, e) => {
-  const s = new Date(a).getTime(), u = {
-    userId: e.userId,
-    evmAccounts: e.evmAccounts?.map((t) => t) ?? [],
-    evmSmartAccounts: e.evmSmartAccounts?.map((t) => t) ?? [],
-    solanaAccounts: e.solanaAccounts?.map((t) => t) ?? [],
-    authenticationMethods: e.authenticationMethods.reduce((t, o) => (t[o.type] = o, t), {})
-  };
-  return {
-    accessToken: c,
-    expiresAt: s,
-    user: u
-  };
-};
+import "viem";
+class p {
+  oauthFlowState = null;
+  oauthStateChangeCallbacks = [];
+  /**
+   * Adds a callback to be called when the OAuth state changes.
+   *
+   * @param callback - The function to call when the OAuth state changes.
+   */
+  async addOAuthStateChangeCallback(t) {
+    this.oauthStateChangeCallbacks.push(t), t(this.oauthFlowState);
+  }
+  /**
+   * Sets the OAuth flow state.
+   *
+   * @param oauthFlowState - The OAuth flow state.
+   */
+  async setOAuthFlowState(t) {
+    this.oauthFlowState = t, this.oauthStateChangeCallbacks.forEach((a) => a(this.oauthFlowState));
+  }
+  /**
+   * Clears the OAuth flow state.
+   */
+  async clearOAuthFlowState() {
+    this.oauthFlowState = null, this.oauthStateChangeCallbacks.forEach((t) => t(null));
+  }
+  /**
+   * Gets the OAuth flow state.
+   *
+   * @returns The OAuth flow state.
+   */
+  async getOAuthFlowState() {
+    return this.oauthFlowState;
+  }
+  /**
+   * Handles the OAuth code.
+   */
+  async handleOAuthCode() {
+    try {
+      const t = await s().getOAuthParams();
+      if (await s().cleanupOAuthParams(), !t || await i().isSignedIn())
+        return;
+      const { providerType: a, code: e, flowId: r, error: o, errorDescription: h } = t;
+      if (o || h) {
+        await this.setOAuthFlowState({
+          providerType: a,
+          status: "error",
+          errorDescription: o ?? h,
+          code: e,
+          flowId: r,
+          error: o
+        });
+        return;
+      }
+      if (!e || !a || !r)
+        return;
+      await this.setOAuthFlowState({
+        providerType: a,
+        status: "pending",
+        code: e,
+        flowId: r
+      }), await u({
+        code: e,
+        providerType: a,
+        flowId: r
+      }), await this.setOAuthFlowState({
+        providerType: a,
+        status: "success",
+        code: e,
+        flowId: r
+      });
+    } catch (t) {
+      const a = t instanceof Error ? t.message : "Unknown error";
+      await s().cleanupOAuthParams(), await this.setOAuthFlowState({
+        status: "error",
+        errorDescription: a
+      });
+    }
+  }
+}
 export {
-  m as toAuthState
+  p as OAuthManager
 };

package/dist/native/index.native20.js

@@ -1,20 +1,18 @@
 import "@coinbase/cdp-api-client";
-import "viem";
-const i = async (n) => await n.isSignedIn();
-async function f(n, r, o) {
-  if (!await i(r))
-    throw new Error("User not signed in");
-  const c = await r.getUser();
-  if ("evmAccount" in n && !c.evmAccounts?.find((t) => t === n.evmAccount))
-    throw new Error("EVM account not found");
-  if ("evmSmartAccount" in n && !c.evmSmartAccounts?.find((t) => t === n.evmSmartAccount))
-    throw new Error("EVM Smart Account not found");
-  if ("solanaAccount" in n && !c.solanaAccounts?.find((t) => t === n.solanaAccount))
-    throw new Error("Solana account not found");
-  const e = await r.getWalletSecretId();
-  return o({ ...n, user: c, walletSecretId: e });
-}
+const m = (c, a, e) => {
+  const s = new Date(a).getTime(), u = {
+    userId: e.userId,
+    evmAccounts: e.evmAccounts?.map((t) => t) ?? [],
+    evmSmartAccounts: e.evmSmartAccounts?.map((t) => t) ?? [],
+    solanaAccounts: e.solanaAccounts?.map((t) => t) ?? [],
+    authenticationMethods: e.authenticationMethods.reduce((t, o) => (t[o.type] = o, t), {})
+  };
+  return {
+    accessToken: c,
+    expiresAt: s,
+    user: u
+  };
+};
 export {
-  i as isSignedIn,
-  f as withAuth
+  m as toAuthState
 };