@coinbase/cdp-core 0.0.25 → 0.0.26

package/dist/esm/{index95.js → index.web85.js}

@@ -1,6 +1,6 @@
-import { withAlg as n } from "./index102.js";
-import c from "./index103.js";
-import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index104.js";
+import { withAlg as n } from "./index.web100.js";
+import c from "./index.web101.js";
+import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.web102.js";
 const s = (r) => r?.[Symbol.toStringTag], o = (r, e, t) => {
   if (e.use !== void 0) {
     let i;

package/dist/esm/{index96.js → index.web86.js}

@@ -1,4 +1,4 @@
-import { JOSENotSupported as f } from "./index72.js";
+import { JOSENotSupported as f } from "./index.web26.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');

package/dist/esm/{index97.js → index.web87.js}

@@ -1,7 +1,7 @@
-import { isJWK as p } from "./index104.js";
-import { decode as m } from "./index92.js";
-import y from "./index105.js";
-import { isCryptoKey as S, isKeyObject as K } from "./index103.js";
+import { isJWK as p } from "./index.web102.js";
+import { decode as m } from "./index.web82.js";
+import y from "./index.web103.js";
+import { isCryptoKey as S, isKeyObject as K } from "./index.web101.js";
 let c;
 const f = async (e, r, s, i = !1) => {
   c ||= /* @__PURE__ */ new WeakMap();

package/dist/esm/index.web88.js

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

package/dist/esm/{index74.js → index.web89.js}

@@ -1,4 +1,4 @@
-import { BaseError as o } from "./index48.js";
+import { BaseError as o } from "./index.web56.js";
 class i extends o {
   constructor({ offset: e }) {
     super(`Offset \`${e}\` cannot be negative.`, {

package/dist/esm/{index5.js → index.web9.js}

@@ -1,7 +1,7 @@
 import { getTypesForEIP712Domain as a } from "viem";
-import { getCurrentUser as s, signEvmHash as i, signEvmTypedData as c, signEvmTransaction as u, signEvmMessage as m } from "./index2.js";
+import { getCurrentUser as s, signEvmHash as i, signEvmTypedData as c, signEvmTransaction as u, signEvmMessage as m } from "./index.web5.js";
 import "@coinbase/cdp-api-client";
-import { toAccount as g } from "./index17.js";
+import { toAccount as g } from "./index.web20.js";
 async function w(r) {
   const n = await s();
   if (!n || !n.evmAccounts || n.evmAccounts.length === 0)

package/dist/esm/index.web90.js

@@ -0,0 +1,22 @@
+const o = /* @__PURE__ */ BigInt(4294967295), i = /* @__PURE__ */ BigInt(32);
+function s(t, r = !1) {
+  return r ? { h: Number(t & o), l: Number(t >> i & o) } : { h: Number(t >> i & o) | 0, l: Number(t & o) | 0 };
+}
+function h(t, r = !1) {
+  const n = t.length;
+  let l = new Uint32Array(n), c = new Uint32Array(n);
+  for (let e = 0; e < n; e++) {
+    const { h: u, l: f } = s(t[e], r);
+    [l[e], c[e]] = [u, f];
+  }
+  return [l, c];
+}
+const m = (t, r, n) => t << n | r >>> 32 - n, A = (t, r, n) => r << n | t >>> 32 - n, B = (t, r, n) => r << n - 32 | t >>> 64 - n, a = (t, r, n) => t << n - 32 | r >>> 64 - n;
+export {
+  s as fromBig,
+  B as rotlBH,
+  a as rotlBL,
+  m as rotlSH,
+  A as rotlSL,
+  h as split
+};

package/dist/esm/{index79.js → index.web91.js}

@@ -1,9 +1,9 @@
-import { maxBytesPerTransaction as y, bytesPerBlob as a, fieldElementsPerBlob as f, bytesPerFieldElement as p } from "./index88.js";
-import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index60.js";
-import { createCursor as B } from "./index49.js";
-import { size as u } from "./index38.js";
-import { hexToBytes as x } from "./index30.js";
-import { bytesToHex as d } from "./index28.js";
+import { maxBytesPerTransaction as y, bytesPerBlob as a, fieldElementsPerBlob as f, bytesPerFieldElement as p } from "./index.web104.js";
+import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index.web67.js";
+import { createCursor as B } from "./index.web57.js";
+import { size as u } from "./index.web46.js";
+import { hexToBytes as x } from "./index.web39.js";
+import { bytesToHex as d } from "./index.web37.js";
 function S(e) {
   const m = e.to ?? (typeof e.data == "string" ? "hex" : "bytes"), i = typeof e.data == "string" ? x(e.data) : e.data, o = u(i);
   if (!o)

package/dist/esm/{index80.js → index.web92.js}

@@ -1,5 +1,5 @@
-import { bytesToHex as i } from "./index28.js";
-import { sha256 as m } from "./index52.js";
+import { bytesToHex as i } from "./index.web37.js";
+import { sha256 as m } from "./index.web60.js";
 function f(t) {
   const { commitment: e, version: s = 1 } = t, n = t.to ?? (typeof e == "string" ? "hex" : "bytes"), o = m(e);
   return o.set([s], 0), n === "bytes" ? o : i(o);

package/dist/esm/index.web93.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/esm/{index90.js → index.web94.js}

@@ -1,7 +1,7 @@
-import { hexToBigInt as n } from "./index44.js";
-import { defineBlock as r } from "./index41.js";
-import { defineTransaction as s, formatTransaction as m } from "./index43.js";
-import { defineTransactionReceipt as l } from "./index46.js";
+import { hexToBigInt as n } from "./index.web52.js";
+import { defineBlock as r } from "./index.web49.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.web51.js";
+import { defineTransactionReceipt as l } from "./index.web54.js";
 const p = {
   block: /* @__PURE__ */ r({
     format(e) {

package/dist/esm/{index91.js → index.web95.js}

@@ -1,9 +1,9 @@
-import { InvalidAddressError as a } from "./index59.js";
-import { isAddress as f } from "./index33.js";
-import { concatHex as p } from "./index34.js";
-import { toHex as i } from "./index28.js";
-import { toRlp as x } from "./index47.js";
-import { serializeTransaction as l } from "./index16.js";
+import { InvalidAddressError as a } from "./index.web28.js";
+import { isAddress as f } from "./index.web29.js";
+import { concatHex as p } from "./index.web42.js";
+import { toHex as i } from "./index.web37.js";
+import { toRlp as x } from "./index.web55.js";
+import { serializeTransaction as l } from "./index.web18.js";
 function T(r, e) {
   return h(r) ? z(r) : l(r, e);
 }

package/dist/esm/index.web96.js

@@ -0,0 +1,20 @@
+function o(t) {
+  if (Uint8Array.prototype.toBase64)
+    return t.toBase64();
+  const e = 32768, n = [];
+  for (let r = 0; r < t.length; r += e)
+    n.push(String.fromCharCode.apply(null, t.subarray(r, r + e)));
+  return btoa(n.join(""));
+}
+function a(t) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(t);
+  const e = atob(t), n = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    n[r] = e.charCodeAt(r);
+  return n;
+}
+export {
+  a as decodeBase64,
+  o as encodeBase64
+};

package/dist/esm/{index99.js → index.web97.js}

@@ -1,4 +1,4 @@
-import { JOSENotSupported as r } from "./index72.js";
+import { JOSENotSupported as r } from "./index.web26.js";
 const S = (e, s) => {
   const a = `SHA-${e.slice(-3)}`;
   switch (e) {

package/dist/esm/index.web98.js

@@ -0,0 +1,10 @@
+const o = (t, r) => {
+  if (t.startsWith("RS") || t.startsWith("PS")) {
+    const { modulusLength: e } = r.algorithm;
+    if (typeof e != "number" || e < 2048)
+      throw new TypeError(`${t} requires key modulusLength to be 2048 bits or larger`);
+  }
+};
+export {
+  o as default
+};

package/dist/esm/{index101.js → index.web99.js}

@@ -1,5 +1,5 @@
-import { checkSigCryptoKey as i } from "./index106.js";
-import o from "./index102.js";
+import { checkSigCryptoKey as i } from "./index.web105.js";
+import o from "./index.web100.js";
 const s = async (t, r, e) => {
   if (r instanceof Uint8Array) {
     if (!t.startsWith("HS"))

package/dist/native/index.native.js

@@ -0,0 +1,47 @@
+import { nativeCrypto as r } from "./index.native2.js";
+import { nativeStorage as e } from "./index.native3.js";
+import { setPlatformServices as o } from "./index.native4.js";
+import { exportEvmAccount as g, getAccessToken as c, getCurrentUser as f, getUserOperation as v, initialize as d, isSignedIn as T, onAuthStateChange as u, sendEvmTransaction as A, sendUserOperation as S, signEvmHash as l, signEvmMessage as x, signEvmTransaction as y, signEvmTypedData as h, signInWithEmail as O, signInWithSms as P, signOut as C, verifyEmailOTP as D, verifySmsOTP as I } from "./index.native5.js";
+import { AuthManager as U } from "./index.native6.js";
+import { APIError as M, ErrorType as k, HttpErrorType as H, SendEvmTransactionWithEndUserAccountBodyNetwork as N } from "@coinbase/cdp-api-client";
+import "viem";
+import { createCDPEmbeddedWallet as b } from "./index.native7.js";
+import { EIP1193ProviderError as z, STANDARD_ERROR_CODES as B } from "./index.native8.js";
+import "ox";
+import "zustand";
+import { toViemAccount as j } from "./index.native9.js";
+import { ModuleResolutionError as F } from "./index.native10.js";
+o({
+  crypto: r,
+  storage: e
+});
+export {
+  M as APIError,
+  U as AuthManager,
+  z as EIP1193ProviderError,
+  k as ErrorType,
+  H as HttpErrorType,
+  F as ModuleResolutionError,
+  B as STANDARD_ERROR_CODES,
+  N as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  b as createCDPEmbeddedWallet,
+  g as exportEvmAccount,
+  c as getAccessToken,
+  f as getCurrentUser,
+  v as getUserOperation,
+  d as initialize,
+  T as isSignedIn,
+  u as onAuthStateChange,
+  A as sendEvmTransaction,
+  S as sendUserOperation,
+  l as signEvmHash,
+  x as signEvmMessage,
+  y as signEvmTransaction,
+  h as signEvmTypedData,
+  O as signInWithEmail,
+  P as signInWithSms,
+  C as signOut,
+  j as toViemAccount,
+  D as verifyEmailOTP,
+  I as verifySmsOTP
+};

package/dist/native/index.native10.js

@@ -0,0 +1,24 @@
+class i extends Error {
+  /**
+   * The name of the missing module.
+   */
+  moduleName;
+  /**
+   * The API or feature that requires the missing module.
+   */
+  requiredFor;
+  /**
+   * Creates a new ModuleResolutionError.
+   *
+   * @param moduleName - The name of the missing module.
+   * @param requiredFor - The API or feature that requires the module.
+   * @param message - Optional custom error message.
+   */
+  constructor(e, s, r) {
+    const o = `${s} is not available in this React Native environment. Please ensure ${e} is installed.`;
+    super(r || o), this.name = "ModuleResolutionError", this.moduleName = e, this.requiredFor = s;
+  }
+}
+export {
+  i as ModuleResolutionError
+};

package/dist/native/index.native100.js

@@ -0,0 +1,12 @@
+function e(t) {
+  return t?.[Symbol.toStringTag] === "CryptoKey";
+}
+function r(t) {
+  return t?.[Symbol.toStringTag] === "KeyObject";
+}
+const n = (t) => e(t) || r(t);
+export {
+  n as default,
+  e as isCryptoKey,
+  r as isKeyObject
+};

package/dist/native/index.native101.js

@@ -0,0 +1,19 @@
+import n from "./index.native78.js";
+function r(t) {
+  return n(t) && typeof t.kty == "string";
+}
+function o(t) {
+  return t.kty !== "oct" && typeof t.d == "string";
+}
+function e(t) {
+  return t.kty !== "oct" && typeof t.d > "u";
+}
+function c(t) {
+  return t.kty === "oct" && typeof t.k == "string";
+}
+export {
+  r as isJWK,
+  o as isPrivateJWK,
+  e as isPublicJWK,
+  c as isSecretJWK
+};

package/dist/native/index.native102.js

@@ -0,0 +1,83 @@
+import { JOSENotSupported as s } from "./index.native27.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.native103.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.native104.js

@@ -0,0 +1,38 @@
+import { hexToBigInt as n } from "./index.native47.js";
+import { defineBlock as r } from "./index.native44.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.native46.js";
+import { defineTransactionReceipt as l } from "./index.native49.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.native105.js

@@ -0,0 +1,44 @@
+import { InvalidAddressError as a } from "./index.native62.js";
+import { isAddress as f } from "./index.native36.js";
+import { concatHex as p } from "./index.native37.js";
+import { toHex as i } from "./index.native31.js";
+import { toRlp as x } from "./index.native50.js";
+import { serializeTransaction as l } from "./index.native19.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.native106.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.native11.js

@@ -0,0 +1,34 @@
+function a(e) {
+  if (typeof btoa < "u")
+    return btoa(
+      Array.from(e).map((t) => String.fromCharCode(t)).join("")
+    );
+  const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let r = "";
+  for (let t = 0; t < e.length; t += 3) {
+    const h = e[t], n = t + 1 < e.length ? e[t + 1] : 0, s = t + 2 < e.length ? e[t + 2] : 0, o = h << 16 | n << 8 | s;
+    r += c.charAt(o >> 18 & 63), r += c.charAt(o >> 12 & 63), r += t + 1 < e.length ? c.charAt(o >> 6 & 63) : "=", r += t + 2 < e.length ? c.charAt(o & 63) : "=";
+  }
+  return r;
+}
+function g(e) {
+  if (typeof atob < "u") {
+    const n = atob(e), s = new Uint8Array(n.length);
+    for (let o = 0; o < n.length; o++)
+      s[o] = n.charCodeAt(o);
+    return s;
+  }
+  const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r = {};
+  for (let n = 0; n < c.length; n++)
+    r[c[n]] = n;
+  const t = e.replace(/[^A-Za-z0-9+/]/g, ""), h = [];
+  for (let n = 0; n < t.length; n += 4) {
+    const s = r[t[n]] || 0, o = r[t[n + 1]] || 0, l = r[t[n + 2]] || 0, f = r[t[n + 3]] || 0, i = s << 18 | o << 12 | l << 6 | f;
+    h.push(i >> 16 & 255), n + 2 < t.length && h.push(i >> 8 & 255), n + 3 < t.length && h.push(i & 255);
+  }
+  return new Uint8Array(h);
+}
+export {
+  g as decodeBase64,
+  a as encodeBase64
+};

package/dist/native/index.native12.js

@@ -0,0 +1,11 @@
+function t(e) {
+  if (typeof TextDecoder < "u")
+    return new TextDecoder().decode(e);
+  let r = "";
+  for (let o = 0; o < e.length; o++)
+    r += String.fromCharCode(e[o]);
+  return decodeURIComponent(escape(r));
+}
+export {
+  t as decodeText
+};

package/dist/native/index.native13.js

@@ -0,0 +1,17 @@
+import "@coinbase/cdp-api-client";
+const r = (u, c, e) => {
+  const s = new Date(c).getTime(), m = {
+    userId: e.userId,
+    evmAccounts: e.evmAccounts?.map((t) => t) ?? [],
+    evmSmartAccounts: e.evmSmartAccounts?.map((t) => t) ?? [],
+    authenticationMethods: e.authenticationMethods.reduce((t, o) => (t[o.type] = o, t), {})
+  };
+  return {
+    accessToken: u,
+    expiresAt: s,
+    user: m
+  };
+};
+export {
+  r as toAuthState
+};

package/dist/native/index.native14.js

@@ -0,0 +1,18 @@
+import "@coinbase/cdp-api-client";
+import "viem";
+const o = async (t) => await t.isSignedIn();
+async function w(t, n, e) {
+  if (!await o(n))
+    throw new Error("User not signed in");
+  const r = await n.getUser();
+  if ("evmAccount" in t && !r.evmAccounts?.find((c) => c === t.evmAccount))
+    throw new Error("EVM account not found");
+  if ("evmSmartAccount" in t && !r.evmSmartAccounts?.find((c) => c === t.evmSmartAccount))
+    throw new Error("EVM Smart Account not found");
+  const i = await n.getWalletSecretId();
+  return e({ ...t, user: r, walletSecretId: i });
+}
+export {
+  o as isSignedIn,
+  w as withAuth
+};