@coinbase/cdp-core 0.0.20 → 0.0.22

package/README.md

@@ -48,6 +48,24 @@ const config: Config = {
 await initialize(config);
 ```
 
+#### Smart Account Configuration
+
+You can configure the SDK to automatically create Smart Accounts for new users by setting `createAccountOnLogin` to `"evm-smart"`:
+
+```ts
+const config: Config = {
+  projectId: "your-project-id",
+  createAccountOnLogin: "evm-smart", // Creates Smart Accounts instead of EOAs
+}
+
+await initialize(config);
+```
+
+When `createAccountOnLogin` is set to `"evm-smart"`, the SDK will:
+1. Create an EOA (Externally Owned Account) first
+2. Use that EOA as the owner to create a Smart Account
+3. Both accounts will be available on the user object
+
 ### Sign In a User
 
 You're now ready to start calling the APIs provided by the package!
@@ -84,7 +102,8 @@ if (signedIn) {
   // Get the user's information
   const user = await getCurrentUser();
   console.log("User ID:", user.userId);
-  console.log("EVM Accounts:", user.evmAccounts);
+  console.log("EVM Accounts (EOAs):", user.evmAccounts);
+  console.log("EVM Smart Accounts:", user.evmSmartAccounts);
 
   // Find the user's email address (if they logged in with email/otp)
   const email = user.authenticationMethods.email?.email;
@@ -163,6 +182,61 @@ const hash = await client.sendRawTransaction({
 });
 ```
 
+### Smart Account Operations
+
+Smart Accounts provide advanced account abstraction features, including user operations and paymaster support.
+
+#### Send User Operations
+
+Send user operations from a Smart Account:
+
+```typescript
+import { sendUserOperation, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const smartAccount = user.evmSmartAccounts[0];
+
+const result = await sendUserOperation({
+  evmSmartAccount: smartAccount,
+  network: "base-sepolia",
+  calls: [
+    {
+      to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      value: 1000000000000000000n, // 1 ETH in wei
+      data: "0x", // Optional contract interaction data
+    }
+  ],
+  // Optional paymaster for gas sponsorship. Get your free Base paymaster URL [from the CDP Portal](https://portal.cdp.coinbase.com/products/node).
+  paymasterUrl: "https://paymaster.example.com",
+});
+
+console.log("User Operation Hash:", result.userOperationHash);
+```
+
+#### Get User Operation Status
+
+After sending a user operation, you can get its status and retrieve the result:
+
+```typescript
+import { getUserOperation } from "@coinbase/cdp-core";
+
+// Get the status of a user operation
+const userOperationResult = await getUserOperation({
+  userOperationHash: result.userOperationHash,
+  evmSmartAccount: smartAccount,
+  network: "base-sepolia"
+});
+
+console.log("Status:", userOperationResult.status); // "pending", "complete", or "failed"
+
+if (userOperationResult.status === "complete") {
+  console.log("Transaction Hash:", userOperationResult.transactionHash);
+  console.log("Block Number:", userOperationResult.receipts?.[0]?.blockNumber);
+} else if (userOperationResult.status === "failed") {
+  console.log("Failure reason:", userOperationResult.receipts?.[0]?.revert?.message);
+}
+```
+
 ### Sign Messages and Typed Data
 
 End users can sign EVM messages, hashes, and typed data to generate signatures for various onchain applications.

package/dist/esm/index.js

@@ -1,34 +1,36 @@
-import { exportEvmAccount as n, getAccessToken as m, getCurrentUser as s, initialize as E, isSignedIn as a, onAuthStateChange as p, sendEvmTransaction as c, signEvmHash as g, signEvmMessage as d, signEvmTransaction as v, signEvmTypedData as T, signInWithEmail as A, signInWithSms as f, signOut as S, verifyEmailOTP as h, verifySmsOTP as u } from "./index2.js";
-import { APIError as y, ErrorType as P, HttpErrorType as l, SendEvmTransactionWithEndUserAccountBodyNetwork as D } from "@coinbase/cdp-api-client";
+import { exportEvmAccount as i, getAccessToken as s, getCurrentUser as m, getUserOperation as a, initialize as E, isSignedIn as p, onAuthStateChange as g, sendEvmTransaction as c, sendUserOperation as d, signEvmHash as v, signEvmMessage as T, signEvmTransaction as A, signEvmTypedData as f, signInWithEmail as O, signInWithSms as S, signOut as h, verifyEmailOTP as u, verifySmsOTP as x } from "./index2.js";
+import { APIError as P, ErrorType as l, HttpErrorType as D, SendEvmTransactionWithEndUserAccountBodyNetwork as I } from "@coinbase/cdp-api-client";
 import "viem";
-import { createCDPEmbeddedWallet as O } from "./index3.js";
-import { EIP1193ProviderError as R, STANDARD_ERROR_CODES as W } from "./index4.js";
+import { createCDPEmbeddedWallet as R } from "./index3.js";
+import { EIP1193ProviderError as W, STANDARD_ERROR_CODES as k } from "./index4.js";
 import "ox";
 import "zustand";
-import { toViemAccount as H } from "./index5.js";
+import { toViemAccount as N } from "./index5.js";
 export {
-  y as APIError,
-  R as EIP1193ProviderError,
-  P as ErrorType,
-  l as HttpErrorType,
-  W as STANDARD_ERROR_CODES,
-  D as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  O as createCDPEmbeddedWallet,
-  n as exportEvmAccount,
-  m as getAccessToken,
-  s as getCurrentUser,
+  P as APIError,
+  W as EIP1193ProviderError,
+  l as ErrorType,
+  D as HttpErrorType,
+  k as STANDARD_ERROR_CODES,
+  I as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  R as createCDPEmbeddedWallet,
+  i as exportEvmAccount,
+  s as getAccessToken,
+  m as getCurrentUser,
+  a as getUserOperation,
   E as initialize,
-  a as isSignedIn,
-  p as onAuthStateChange,
+  p as isSignedIn,
+  g as onAuthStateChange,
   c as sendEvmTransaction,
-  g as signEvmHash,
-  d as signEvmMessage,
-  v as signEvmTransaction,
-  T as signEvmTypedData,
-  A as signInWithEmail,
-  f as signInWithSms,
-  S as signOut,
-  H as toViemAccount,
-  h as verifyEmailOTP,
-  u as verifySmsOTP
+  d as sendUserOperation,
+  v as signEvmHash,
+  T as signEvmMessage,
+  A as signEvmTransaction,
+  f as signEvmTypedData,
+  O as signInWithEmail,
+  S as signInWithSms,
+  h as signOut,
+  N as toViemAccount,
+  u as verifyEmailOTP,
+  x as verifySmsOTP
 };

package/dist/esm/index15.js

@@ -1,15 +1,15 @@
-import { InvalidLegacyVError as H } from "./index55.js";
-import { serializeAuthorizationList as g } from "./index28.js";
+import { InvalidLegacyVError as H } from "./index54.js";
+import { serializeAuthorizationList as g } from "./index26.js";
 import { blobsToCommitments as B } from "./index62.js";
 import { blobsToProofs as V } from "./index63.js";
 import { commitmentsToVersionedHashes as C } from "./index64.js";
 import { toBlobSidecars as k } from "./index65.js";
-import { concatHex as h } from "./index34.js";
-import { trim as T } from "./index40.js";
-import { numberToHex as o, bytesToHex as w } from "./index29.js";
-import { toRlp as b } from "./index47.js";
-import { assertTransactionEIP1559 as S, assertTransactionEIP2930 as _, assertTransactionEIP4844 as R, assertTransactionEIP7702 as Y, assertTransactionLegacy as j } from "./index56.js";
-import { getTransactionType as q } from "./index54.js";
+import { concatHex as h } from "./index33.js";
+import { trim as T } from "./index39.js";
+import { numberToHex as o, bytesToHex as w } from "./index27.js";
+import { toRlp as b } from "./index46.js";
+import { assertTransactionEIP1559 as S, assertTransactionEIP2930 as _, assertTransactionEIP4844 as R, assertTransactionEIP7702 as Y, assertTransactionLegacy as j } from "./index55.js";
+import { getTransactionType as q } from "./index53.js";
 import { serializeAccessList as v } from "./index66.js";
 function te(e, r) {
   const i = q(e);

package/dist/esm/index16.js

@@ -1,5 +1,5 @@
-import { InvalidAddressError as s } from "./index25.js";
-import { isAddress as a } from "./index26.js";
+import { InvalidAddressError as s } from "./index58.js";
+import { isAddress as a } from "./index32.js";
 function r(n) {
   if (typeof n == "string") {
     if (!a(n, { strict: !1 }))

package/dist/esm/index2.js

@@ -1,89 +1,89 @@
-import { configureCdpApiClient as I, setAuthManager as l, initiateAuthentication as v, createEndUserEvmAccount as A, verifyEmailAuthentication as E, verifySmsAuthentication as k, signEvmHashWithEndUserAccount as S, signEvmTransactionWithEndUserAccount as M, sendEvmTransactionWithEndUserAccount as T, signEvmMessageWithEndUserAccount as U, signEvmTypedDataWithEndUserAccount as C, exportEndUserEvmAccount as j } from "@coinbase/cdp-api-client";
-import { AuthManager as P } from "./index6.js";
-import { toAuthState as d } from "./index7.js";
+import { configureCdpApiClient as A, setAuthManager as v, initiateAuthentication as S, createEndUserEvmAccount as E, createEndUserEvmSmartAccount as g, verifyEmailAuthentication as k, verifySmsAuthentication as U, signEvmHashWithEndUserAccount as M, signEvmTransactionWithEndUserAccount as T, sendEvmTransactionWithEndUserAccount as j, signEvmMessageWithEndUserAccount as O, signEvmTypedDataWithEndUserAccount as P, sendUserOperationWithEndUserAccount as C, getUserOperationWithEndUserAccount as x, exportEndUserEvmAccount as H } from "@coinbase/cdp-api-client";
+import { AuthManager as W } from "./index6.js";
+import { toAuthState as m } from "./index7.js";
 import { withAuth as o } from "./index8.js";
-import { createExportKeyPair as x } from "./index9.js";
-import { decryptWithPrivateKey as b } from "./index10.js";
-import { MockAuthManager as K } from "./index11.js";
-import { mockUser as g } from "./index12.js";
-import { isChainSupportedForCDPSends as W } from "./index13.js";
-import { getConfig as n, setCoreAuthManager as m, getCoreAuthManager as s, setConfig as D } from "./index14.js";
+import { createExportKeyPair as b } from "./index9.js";
+import { decryptWithPrivateKey as K } from "./index10.js";
+import { MockAuthManager as D } from "./index11.js";
+import { mockUser as p } from "./index12.js";
+import { isChainSupportedForCDPSends as z } from "./index13.js";
+import { getConfig as t, setCoreAuthManager as h, getCoreAuthManager as s, setConfig as N } from "./index14.js";
 import "viem";
-import { serializeTransaction as p } from "./index15.js";
-const Q = async (e) => {
+import { serializeTransaction as w } from "./index15.js";
+const _ = async (e) => {
   if (!e.projectId)
     throw new Error("Project ID is required");
   let r;
   try {
-    r = n().projectId !== e.projectId;
+    r = t().projectId !== e.projectId;
   } catch {
     r = !0;
   }
-  if (D(e), n().useMock) {
-    m(new K(n().projectId));
+  if (N(e), t().useMock) {
+    h(new D(t().projectId));
     return;
   }
-  if (I({
-    debugging: n().debugging,
-    basePath: n().basePath
+  if (A({
+    debugging: t().debugging,
+    basePath: t().basePath
   }), r) {
-    const t = new P(n().projectId);
-    m(t), l(t);
+    const n = new W(t().projectId);
+    h(n), v(n);
   }
   await s().ensureInitialized();
-}, R = async (e) => h({
+}, ee = async (e) => y({
   email: e.email,
   type: "email"
-}), X = async (e) => h({
+}), te = async (e) => y({
   phoneNumber: e.phoneNumber,
   type: "sms"
-}), Y = async (e) => w(
+}), re = async (e) => l(
   e,
   "Mock email OTP verified",
-  (r, t) => E(r, t)
-), Z = async (e) => w(
+  (r, n) => k(r, n)
+), ne = async (e) => l(
   e,
   "Mock SMS OTP verified",
-  (r, t) => k(r, t)
-), _ = async () => s().getUser(), ee = async () => s().isSignedIn(), te = async () => {
-  if (n().useMock) {
+  (r, n) => U(r, n)
+), se = async () => s().getUser(), ae = async () => s().isSignedIn(), ce = async () => {
+  if (t().useMock) {
     await s().signOut();
     return;
   }
   if (!await s().isSignedIn())
     throw new Error("User not signed in");
   await s().signOut();
-}, ne = async () => s().getToken(), re = (e) => {
+}, ie = async () => s().getToken(), oe = (e) => {
   s().addAuthStateChangeCallback(e);
-}, se = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
-  signature: (await S(n().projectId, r.userId, {
+}, ue = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
+  signature: (await M(t().projectId, r.userId, {
     hash: e.hash,
     address: e.evmAccount,
-    walletSecretId: t
+    walletSecretId: n
   })).signature
-})), ae = async (e) => n().useMock ? { signedTransaction: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => {
-  const i = p(e.transaction);
+})), de = async (e) => t().useMock ? { signedTransaction: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => {
+  const i = w(e.transaction);
   return {
-    signedTransaction: (await M(
-      n().projectId,
+    signedTransaction: (await T(
+      t().projectId,
       r.userId,
       {
         transaction: i,
         address: e.evmAccount,
-        walletSecretId: t
+        walletSecretId: n
       }
     )).signedTransaction
   };
-}), ie = async (e) => {
-  if (!W(e.network))
+}), me = async (e) => {
+  if (!z(e.network))
     throw new Error(`Chain ${e.network} is not supported by the CDP Apis`);
-  if (n().useMock)
+  if (t().useMock)
     return { transactionHash: "0x0" };
-  const r = p(e.transaction);
-  return o(e, s(), async ({ user: t, walletSecretId: i }) => ({
-    transactionHash: (await T(
-      n().projectId,
-      t.userId,
+  const r = w(e.transaction);
+  return o(e, s(), async ({ user: n, walletSecretId: i }) => ({
+    transactionHash: (await j(
+      t().projectId,
+      n.userId,
       {
         transaction: r,
         address: e.evmAccount,
@@ -92,99 +92,166 @@ const Q = async (e) => {
       }
     )).transactionHash
   }));
-}, ce = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
-  signature: (await U(n().projectId, r.userId, {
+}, ge = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
+  signature: (await O(t().projectId, r.userId, {
     message: e.message,
     address: e.evmAccount,
-    walletSecretId: t
+    walletSecretId: n
   })).signature
-})), oe = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
-  signature: (await C(n().projectId, r.userId, {
+})), pe = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
+  signature: (await P(t().projectId, r.userId, {
     typedData: e.typedData,
     address: e.evmAccount,
-    walletSecretId: t
+    walletSecretId: n
   })).signature
-})), ue = async (e) => {
-  if (n().useMock)
+})), he = async (e) => t().useMock ? {
+  userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
+} : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
+  userOperationHash: (await C(
+    t().projectId,
+    r.userId,
+    e.evmSmartAccount,
+    {
+      network: e.network,
+      calls: e.calls.map((a) => ({
+        to: a.to,
+        value: String(a.value ?? 0n),
+        data: a.data ?? "0x"
+      })),
+      walletSecretId: n,
+      useCdpPaymaster: e.useCdpPaymaster ?? !1,
+      paymasterUrl: e.paymasterUrl
+    }
+  )).userOpHash
+})), we = async (e) => t().useMock ? {
+  userOpHash: e.userOperationHash,
+  network: e.network,
+  calls: [
+    {
+      to: "0x1234567890123456789012345678901234567890",
+      value: "0",
+      data: "0x"
+    }
+  ],
+  status: "complete",
+  transactionHash: "0x9876543210987654321098765432109876543210987654321098765432109876",
+  receipts: []
+} : o(e, s(), async ({ user: r }) => await x(
+  t().projectId,
+  r.userId,
+  e.evmSmartAccount,
+  e.userOperationHash
+)), ye = async (e) => {
+  if (t().useMock)
     return {
       privateKey: "mock-private-key"
     };
-  const r = await x();
-  return o(e, s(), async ({ user: t, walletSecretId: i }) => {
-    const a = await j(n().projectId, t.userId, {
+  const r = await b();
+  return o(e, s(), async ({ user: n, walletSecretId: i }) => {
+    const a = await H(t().projectId, n.userId, {
       address: e.evmAccount,
       walletSecretId: i,
       exportEncryptionKey: r.publicKeyBase64
     });
     return {
-      privateKey: await b(
+      privateKey: await K(
         r.privateKey,
         a.encryptedPrivateKey
       )
     };
   });
-}, h = async (e) => {
-  if (n().useMock)
+}, y = async (e) => {
+  if (t().useMock)
     return {
       message: "Mock sign in initiated",
       flowId: "mock-flow-id"
     };
   if (await s().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const t = await v(n().projectId, e);
+  const n = await S(t().projectId, e);
   return {
-    flowId: t.flowId,
-    message: t.message
+    flowId: n.flowId,
+    message: n.message
   };
-}, w = async (e, r, t) => {
-  if (n().useMock)
+}, l = async (e, r, n) => {
+  if (t().useMock)
     return await s().setAuthState({
       accessToken: "mock-access-token",
       expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
-      user: g
+      user: p
     }), {
       message: r,
-      user: g,
+      user: p,
       isNewUser: !1
     };
   if (await s().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const a = await t(n().projectId, {
+  const a = await n(t().projectId, {
     flowId: e.flowId,
     otp: e.otp
   });
-  let c = d(a.accessToken, a.validUntil, a.endUser);
+  let c = m(a.accessToken, a.validUntil, a.endUser);
   if (await s().setAuthState(c), !c.user.evmAccounts || c.user.evmAccounts.length === 0)
     try {
-      const u = await s().getWalletSecretId(), f = await A(n().projectId, c.user.userId, {
+      const u = await s().getWalletSecretId();
+      let d = await E(t().projectId, c.user.userId, {
         walletSecretId: u
       });
-      c = d(a.accessToken, a.validUntil, f), await s().setAuthState(c);
+      if (t().createAccountOnLogin === "evm-smart") {
+        const [I] = d.evmAccounts;
+        d = await g(
+          t().projectId,
+          c.user.userId,
+          {
+            owner: I,
+            enableSpendPermissions: !1
+            // Defaulting to false until the feature is ready.
+          }
+        );
+      }
+      c = m(a.accessToken, a.validUntil, d), await s().setAuthState(c);
     } catch (u) {
       throw new Error(`Failed to create EVM account: ${u}`);
     }
-  const y = await s().getUser();
+  if (t().createAccountOnLogin === "evm-smart" && (!c.user.evmSmartAccounts || c.user.evmSmartAccounts.length === 0))
+    try {
+      const [u] = c.user.evmAccounts, d = await g(
+        t().projectId,
+        c.user.userId,
+        {
+          owner: u,
+          enableSpendPermissions: !1
+          // Defaulting to false until the feature is ready.
+        }
+      );
+      c = m(a.accessToken, a.validUntil, d), await s().setAuthState(c);
+    } catch (u) {
+      throw new Error(`Failed to create EVM Smart Account: ${u}`);
+    }
+  const f = await s().getUser();
   return {
     message: a.message,
-    user: y,
+    user: f,
     isNewUser: a.isNewEndUser
   };
 };
 export {
-  ue as exportEvmAccount,
-  ne as getAccessToken,
-  _ as getCurrentUser,
-  Q as initialize,
-  ee as isSignedIn,
-  re as onAuthStateChange,
-  ie as sendEvmTransaction,
-  se as signEvmHash,
-  ce as signEvmMessage,
-  ae as signEvmTransaction,
-  oe as signEvmTypedData,
-  R as signInWithEmail,
-  X as signInWithSms,
-  te as signOut,
-  Y as verifyEmailOTP,
-  Z as verifySmsOTP
+  ye as exportEvmAccount,
+  ie as getAccessToken,
+  se as getCurrentUser,
+  we as getUserOperation,
+  _ as initialize,
+  ae as isSignedIn,
+  oe as onAuthStateChange,
+  me as sendEvmTransaction,
+  he as sendUserOperation,
+  ue as signEvmHash,
+  ge as signEvmMessage,
+  de as signEvmTransaction,
+  pe as signEvmTypedData,
+  ee as signInWithEmail,
+  te as signInWithSms,
+  ce as signOut,
+  re as verifyEmailOTP,
+  ne as verifySmsOTP
 };

package/dist/esm/index20.js

@@ -1,5 +1,5 @@
 import { chainConfig as a } from "./index81.js";
-import { defineChain as t } from "./index27.js";
+import { defineChain as t } from "./index25.js";
 const e = 11155111, r = /* @__PURE__ */ t({
   ...a,
   id: 84532,

package/dist/esm/index25.js

@@ -1,15 +1,11 @@
-import { BaseError as r } from "./index48.js";
-class d extends r {
-  constructor({ address: s }) {
-    super(`Address "${s}" is invalid.`, {
-      metaMessages: [
-        "- Address must be a hex value of 20 bytes (40 hex characters).",
-        "- Address must match its checksum counterpart."
-      ],
-      name: "InvalidAddressError"
-    });
-  }
+function n(e) {
+  return {
+    formatters: void 0,
+    fees: void 0,
+    serializers: void 0,
+    ...e
+  };
 }
 export {
-  d as InvalidAddressError
+  n as defineChain
 };

package/dist/esm/index26.js

@@ -1,14 +1,20 @@
-import { LruMap as u } from "./index33.js";
-import { checksumAddress as c } from "./index30.js";
-const i = /^0x[a-fA-F0-9]{40}$/, r = /* @__PURE__ */ new u(8192);
-function h(t, s) {
-  const { strict: n = !0 } = s ?? {}, e = `${t}.${n}`;
-  if (r.has(e))
-    return r.get(e);
-  const o = i.test(t) ? t.toLowerCase() === t ? !0 : n ? c(t) === t : !0 : !1;
-  return r.set(e, o), o;
+import { toHex as i } from "./index27.js";
+import { toYParitySignatureArray as c } from "./index15.js";
+function f(r) {
+  if (!r || r.length === 0)
+    return [];
+  const t = [];
+  for (const o of r) {
+    const { chainId: n, nonce: e, ...s } = o, a = o.address;
+    t.push([
+      n ? i(n) : "0x",
+      a,
+      e ? i(e) : "0x",
+      ...c({}, s)
+    ]);
+  }
+  return t;
 }
 export {
-  h as isAddress,
-  r as isAddressCache
+  f as serializeAuthorizationList
 };

package/dist/esm/index27.js

@@ -1,11 +1,48 @@
-function n(e) {
-  return {
-    formatters: void 0,
-    fees: void 0,
-    serializers: void 0,
-    ...e
-  };
+import { IntegerOutOfRangeError as x } from "./index49.js";
+import { pad as s } from "./index35.js";
+import { assertSize as c } from "./index43.js";
+const b = /* @__PURE__ */ Array.from({ length: 256 }, (n, e) => e.toString(16).padStart(2, "0"));
+function B(n, e = {}) {
+  return typeof n == "number" || typeof n == "bigint" ? y(n, e) : typeof n == "string" ? $(n, e) : typeof n == "boolean" ? z(n, e) : m(n, e);
+}
+function z(n, e = {}) {
+  const t = `0x${Number(n)}`;
+  return typeof e.size == "number" ? (c(t, { size: e.size }), s(t, { size: e.size })) : t;
+}
+function m(n, e = {}) {
+  let t = "";
+  for (let i = 0; i < n.length; i++)
+    t += b[n[i]];
+  const r = `0x${t}`;
+  return typeof e.size == "number" ? (c(r, { size: e.size }), s(r, { dir: "right", size: e.size })) : r;
+}
+function y(n, e = {}) {
+  const { signed: t, size: r } = e, i = BigInt(n);
+  let o;
+  r ? t ? o = (1n << BigInt(r) * 8n - 1n) - 1n : o = 2n ** (BigInt(r) * 8n) - 1n : typeof n == "number" && (o = BigInt(Number.MAX_SAFE_INTEGER));
+  const g = typeof o == "bigint" && t ? -o - 1n : 0;
+  if (o && i > o || i < g) {
+    const f = typeof n == "bigint" ? "n" : "";
+    throw new x({
+      max: o ? `${o}${f}` : void 0,
+      min: `${g}${f}`,
+      signed: t,
+      size: r,
+      value: `${n}${f}`
+    });
+  }
+  const u = `0x${(t && i < 0 ? (1n << BigInt(r * 8)) + BigInt(i) : i).toString(16)}`;
+  return r ? s(u, { size: r }) : u;
+}
+const d = /* @__PURE__ */ new TextEncoder();
+function $(n, e = {}) {
+  const t = d.encode(n);
+  return m(t, e);
 }
 export {
-  n as defineChain
+  z as boolToHex,
+  m as bytesToHex,
+  y as numberToHex,
+  $ as stringToHex,
+  B as toHex
 };