@moon-x/core 0.2.0

package/dist/lib/index.js

@@ -0,0 +1,1622 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  DEFAULT_AUTH_URL: () => DEFAULT_AUTH_URL,
+  EthereumSiweMessage: () => EthereumSiweMessage,
+  SiwsMessage: () => SiwsMessage,
+  SolanaTransactionParser: () => SolanaTransactionParser,
+  arrayLikeToBytes: () => arrayLikeToBytes,
+  authState: () => authState,
+  broadcastEthereumRaw: () => broadcastEthereumRaw,
+  broadcastSolanaSigned: () => broadcastSolanaSigned,
+  bs58ToBytes: () => bs58ToBytes,
+  buildUrl: () => buildUrl,
+  clearParentAssertCache: () => clearParentAssertCache,
+  createManualSiweMessage: () => createManualSiweMessage,
+  estimateEvmGas: () => estimateEvmGas,
+  estimateEvmGasReserve: () => estimateEvmGasReserve,
+  formatPasskeyLabel: () => formatPasskeyLabel,
+  fromB64url: () => fromB64url,
+  generatePasskeyUserId: () => generatePasskeyUserId,
+  getAssertCacheTtlMs: () => getAssertCacheTtlMs,
+  getChainById: () => getChainById,
+  getDefaultChain: () => getDefaultChain,
+  getEvmGasPrice: () => getEvmGasPrice,
+  getEvmMaxPriorityFeePerGas: () => getEvmMaxPriorityFeePerGas,
+  getEvmNonce: () => getEvmNonce,
+  getInstructionsForHTML: () => getInstructionsForHTML,
+  getRpcUrl: () => getRpcUrl,
+  getSOLTransfersFromInstructions: () => getSOLTransfersFromInstructions,
+  getTransferInfoFromInstructions: () => getTransferInfoFromInstructions,
+  isChainSupported: () => isChainSupported,
+  prepareEvmSendTransaction: () => prepareEvmSendTransaction,
+  prepareEvmSignTransaction: () => prepareEvmSignTransaction,
+  readParentAssertCache: () => readParentAssertCache,
+  resolveEvmChain: () => resolveEvmChain,
+  resolvePasskeyMetadata: () => resolvePasskeyMetadata,
+  sanitizeUserData: () => sanitizeUserData,
+  serializeEthereumTransaction: () => serializeEthereumTransaction,
+  setAssertCacheTtlMs: () => setAssertCacheTtlMs,
+  setChainRpcUrl: () => setChainRpcUrl,
+  toB64url: () => toB64url,
+  validateChainConfig: () => validateChainConfig,
+  verifyIdToken: () => verifyIdToken,
+  withClearOnFailure: () => withClearOnFailure,
+  writeParentAssertCache: () => writeParentAssertCache
+});
+module.exports = __toCommonJS(lib_exports);
+
+// src/lib/auth/authentication-state.ts
+var AuthenticationState = class {
+  constructor() {
+    this.email = null;
+  }
+  setEmail(email) {
+    this.email = email;
+  }
+  getEmail() {
+    return this.email;
+  }
+  clearEmail() {
+    this.email = null;
+  }
+  clear() {
+    this.clearEmail();
+  }
+};
+var authState = new AuthenticationState();
+
+// src/lib/auth/sanitize-user.ts
+function sanitizeUserData(userData) {
+  if (!userData) return null;
+  const publicUser = {
+    user_id: userData.user_id,
+    first_name: userData.first_name,
+    last_name: userData.last_name,
+    status: userData.status,
+    active: userData.active,
+    is_guest: userData.is_guest,
+    emails: userData.emails,
+    phone_numbers: userData.phone_numbers,
+    idp_providers: userData.idp_providers,
+    wallets: userData.wallets,
+    totps: userData.totps,
+    webauthn_credentials: userData.webauthn_credentials,
+    created_at: userData.created_at,
+    updated_at: userData.updated_at
+  };
+  return Object.fromEntries(
+    Object.entries(publicUser).filter(([_, value]) => value !== void 0)
+  );
+}
+
+// src/utils/get-api-url.ts
+var getMoonKeyApiUrl = () => {
+  if (process.env?.NEXT_PUBLIC_MOONKEY_API_URL) {
+    return process.env.NEXT_PUBLIC_MOONKEY_API_URL;
+  }
+  if (process.env?.NEXT_PUBLIC_MOONKEY_IFRAME_URL) {
+    const iframeUrl = process.env.NEXT_PUBLIC_MOONKEY_IFRAME_URL;
+    if (iframeUrl.includes("staging") || iframeUrl.includes("auth-staging")) {
+      return "https://api.moonx-dev.com";
+    }
+  }
+  if (process.env?.NEXT_PUBLIC_VERCEL_ENV === "preview") {
+    return "https://api.moonx-dev.com";
+  }
+  return "https://api.moonx-dev.com";
+};
+
+// src/lib/auth/verify-id-token.ts
+var verifyIdToken = async (publishableKey, idToken) => {
+  try {
+    const apiUrl = getMoonKeyApiUrl();
+    const response = await fetch(
+      `${apiUrl}/v1/auth/users/public/id_token/verify`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `PublicToken ${publishableKey}`,
+          "X-Streambird-id-token": idToken
+        }
+      }
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      return {
+        success: false,
+        error: errorData.message || `Failed to verify ID token: ${response.statusText}`,
+        statusCode: response.status
+      };
+    }
+    const responseData = await response.json();
+    const user = responseData.user || responseData;
+    return {
+      success: true,
+      user
+    };
+  } catch (error) {
+    console.error("Error verifying ID token:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error occurred"
+    };
+  }
+};
+
+// src/lib/passkey/passkey-codec.ts
+var fromB64url = (b64url) => {
+  const base64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+};
+var toB64url = (bytes) => {
+  let str = "";
+  for (let i = 0; i < bytes.length; i++) str += String.fromCharCode(bytes[i]);
+  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+
+// src/lib/passkey/passkey-cache.ts
+var cacheTtlMs = 0;
+var cache = null;
+var setAssertCacheTtlMs = (ms) => {
+  cacheTtlMs = Math.max(0, Math.floor(ms));
+  if (cacheTtlMs === 0) {
+    cache = null;
+  }
+};
+var getAssertCacheTtlMs = () => cacheTtlMs;
+var clearParentAssertCache = () => {
+  cache = null;
+};
+var readParentAssertCache = () => {
+  if (cacheTtlMs <= 0) return null;
+  if (!cache) return null;
+  if (Date.now() - cache.ts >= cacheTtlMs) return null;
+  return {
+    userHandleB64url: cache.userHandleB64url,
+    credentialIdB64url: cache.credentialIdB64url
+  };
+};
+var writeParentAssertCache = (entry) => {
+  if (cacheTtlMs <= 0) return;
+  cache = { ...entry, ts: Date.now() };
+};
+var withClearOnFailure = async (fn) => {
+  try {
+    return await fn();
+  } catch (error) {
+    clearParentAssertCache();
+    throw error;
+  }
+};
+var generatePasskeyUserId = () => {
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  return { userIdB64url: toB64url(bytes), userIdBytes: bytes };
+};
+
+// src/lib/passkey/passkey-aaguid-registry.json
+var passkey_aaguid_registry_default = {
+  "a11a5faa-9f32-4b8c-8c5d-2f7d13e8c942": {
+    name: "AliasVault"
+  },
+  "ea9b8d66-4d01-1d21-3ce4-b6b48cb575d4": {
+    name: "Google Password Manager"
+  },
+  "adce0002-35bc-c60a-648b-0b25f1f05503": {
+    name: "Chrome on Mac"
+  },
+  "08987058-cadc-4b81-b6e1-30de50dcbe96": {
+    name: "Windows Hello"
+  },
+  "9ddd1817-af5a-4672-a2b9-3e3dd95000a9": {
+    name: "Windows Hello"
+  },
+  "6028b017-b1d4-4c02-b4b3-afcdafc96bb2": {
+    name: "Windows Hello"
+  },
+  "dd4ec289-e01d-41c9-bb89-70fa845d4bf2": {
+    name: "iCloud Keychain (Managed)"
+  },
+  "531126d6-e717-415c-9320-3d9aa6981239": {
+    name: "Dashlane"
+  },
+  "bada5566-a7aa-401f-bd96-45619a55120d": {
+    name: "1Password"
+  },
+  "b84e4048-15dc-4dd0-8640-f4f60813c8af": {
+    name: "NordPass"
+  },
+  "0ea242b4-43c4-4a1b-8b17-dd6d0b6baec6": {
+    name: "Keeper"
+  },
+  "891494da-2c90-4d31-a9cd-4eab0aed1309": {
+    name: "S\xE9same"
+  },
+  "f3809540-7f14-49c1-a8b3-8f813b225541": {
+    name: "Enpass"
+  },
+  "b5397666-4885-aa6b-cebf-e52262a439a2": {
+    name: "Chromium Browser"
+  },
+  "771b48fd-d3d4-4f74-9232-fc157ab0507a": {
+    name: "Edge on Mac"
+  },
+  "39a5647e-1853-446c-a1f6-a79bae9f5bc7": {
+    name: "IDmelon"
+  },
+  "d548826e-79b4-db40-a3d8-11116f7e8349": {
+    name: "Bitwarden"
+  },
+  "fbfc3007-154e-4ecc-8c0b-6e020557d7bd": {
+    name: "Apple Passwords"
+  },
+  "53414d53-554e-4700-0000-000000000000": {
+    name: "Samsung Pass"
+  },
+  "66a0ccb3-bd6a-191f-ee06-e375c50b9846": {
+    name: "Thales Bio iOS SDK"
+  },
+  "8836336a-f590-0921-301d-46427531eee6": {
+    name: "Thales Bio Android SDK"
+  },
+  "cd69adb5-3c7a-deb9-3177-6800ea6cb72a": {
+    name: "Thales PIN Android SDK"
+  },
+  "17290f1e-c212-34d0-1423-365d729f09d9": {
+    name: "Thales PIN iOS SDK"
+  },
+  "50726f74-6f6e-5061-7373-50726f746f6e": {
+    name: "Proton Pass"
+  },
+  "fdb141b2-5d84-443e-8a35-4698c205a502": {
+    name: "KeePassXC"
+  },
+  "eaecdef2-1c31-5634-8639-f1cbd9c00a08": {
+    name: "KeePassDX"
+  },
+  "cc45f64e-52a2-451b-831a-4edd8022a202": {
+    name: "ToothPic Passkey Provider"
+  },
+  "bfc748bb-3429-4faa-b9f9-7cfa9f3b76d0": {
+    name: "iPasswords"
+  },
+  "b35a26b2-8f6e-4697-ab1d-d44db4da28c6": {
+    name: "Zoho Vault"
+  },
+  "b78a0a55-6ef8-d246-a042-ba0f6d55050c": {
+    name: "LastPass"
+  },
+  "de503f9c-21a4-4f76-b4b7-558eb55c6f89": {
+    name: "Devolutions"
+  },
+  "22248c4c-7a12-46e2-9a41-44291b373a4d": {
+    name: "LogMeOnce"
+  },
+  "a10c6dd9-465e-4226-8198-c7c44b91c555": {
+    name: "Kaspersky Password Manager"
+  },
+  "d350af52-0351-4ba2-acd3-dfeeadc3f764": {
+    name: "pwSafe"
+  },
+  "d3452668-01fd-4c12-926c-83a4204853aa": {
+    name: "Microsoft Password Manager"
+  },
+  "6d212b28-a2c1-4638-b375-5932070f62e9": {
+    name: "initial"
+  },
+  "d49b2120-b865-4191-8cea-be84a52b0485": {
+    name: "Heimlane Vault"
+  },
+  "e8b7f4a2-c3d5-e6f7-890a-b1c2d3e4f567": {
+    name: "Sherlocked"
+  },
+  "d9be9d39-e6a6-4c28-a581-32b044d986e4": {
+    name: "Sticky Password Manager"
+  },
+  "70617373-7761-6c6c-6669-646f32303236": {
+    name: "Passwall"
+  },
+  "c9cadfc9-89a9-489e-a25a-c7e86a4d5f15": {
+    name: "Burp Suite Navigation Recorder"
+  }
+};
+
+// src/lib/passkey/passkey-metadata.ts
+var aaguidRegistry = passkey_aaguid_registry_default;
+var ZERO_AAGUID = "00000000-0000-0000-0000-000000000000";
+function resolveProvider(aaguid, transports) {
+  if (!aaguid) return "Unknown authenticator";
+  const entry = aaguidRegistry[aaguid];
+  if (entry?.name) return entry.name;
+  if (aaguid === ZERO_AAGUID) {
+    if (transports.includes("internal")) return "iCloud Keychain";
+    return "Unknown authenticator";
+  }
+  return "Unknown authenticator";
+}
+function resolveFormFactor(transports) {
+  if (transports.includes("hybrid")) return "hybrid";
+  if (transports.includes("internal")) return "platform";
+  if (transports.includes("usb") || transports.includes("nfc") || transports.includes("ble")) {
+    return "roaming";
+  }
+  return "unknown";
+}
+function formatPasskeyLabel(input) {
+  if (input.nickname && input.nickname.trim()) return input.nickname.trim();
+  const transports = input.transports ?? [];
+  const providerName = resolveProvider(input.aaguid, transports);
+  if (providerName.includes(" on ")) return providerName;
+  if (input.registeredBrowser) {
+    return `${providerName} on ${input.registeredBrowser}`;
+  }
+  return providerName;
+}
+function resolvePasskeyMetadata(input) {
+  const transports = input.transports ?? [];
+  const providerName = resolveProvider(input.aaguid, transports);
+  return {
+    providerName,
+    formFactor: resolveFormFactor(transports),
+    isCloudSynced: !!input.backupState,
+    label: formatPasskeyLabel(input)
+  };
+}
+
+// src/lib/ethereum/chains.ts
+var import_viem = require("viem");
+function setChainRpcUrl(chain, rpcUrl) {
+  return {
+    ...chain,
+    rpcUrls: {
+      ...chain.rpcUrls,
+      default: {
+        http: [rpcUrl],
+        webSocket: chain.rpcUrls.default.webSocket
+      }
+    }
+  };
+}
+function getRpcUrl(chain) {
+  return chain.rpcUrls.default.http[0];
+}
+async function getEvmMaxPriorityFeePerGas(rpcUrl) {
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "eth_maxPriorityFeePerGas",
+      params: []
+    })
+  });
+  const result = await response.json();
+  if (result.error) {
+    throw new Error(
+      result.error.message || "eth_maxPriorityFeePerGas failed"
+    );
+  }
+  return BigInt(result.result);
+}
+async function getEvmGasPrice(rpcUrl) {
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "eth_gasPrice",
+      params: []
+    })
+  });
+  const result = await response.json();
+  if (result.error) {
+    throw new Error(result.error.message || "eth_gasPrice failed");
+  }
+  return BigInt(result.result);
+}
+async function estimateEvmGas(rpcUrl, tx) {
+  const valueHex = (() => {
+    const v = tx.value;
+    if (v == null) return "0x0";
+    if (typeof v === "bigint") return `0x${v.toString(16)}`;
+    if (typeof v === "number") return `0x${BigInt(v).toString(16)}`;
+    if (typeof v === "string") {
+      if (v === "") return "0x0";
+      if (v.startsWith("0x")) return v;
+      if (v.includes(".")) {
+        return `0x${(0, import_viem.parseEther)(v).toString(16)}`;
+      }
+      try {
+        return `0x${BigInt(v).toString(16)}`;
+      } catch {
+        return "0x0";
+      }
+    }
+    return "0x0";
+  })();
+  const params = {
+    from: tx.from,
+    value: valueHex,
+    data: tx.data || "0x"
+  };
+  if (tx.to) params.to = tx.to;
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "eth_estimateGas",
+      params: [params]
+    })
+  });
+  const result = await response.json();
+  if (result.error) {
+    throw new Error(result.error.message || "eth_estimateGas failed");
+  }
+  return BigInt(result.result);
+}
+async function getEvmNonce(rpcUrl, address) {
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "eth_getTransactionCount",
+      params: [address, "pending"]
+    })
+  });
+  const result = await response.json();
+  if (result.error) {
+    throw new Error(result.error.message || "eth_getTransactionCount failed");
+  }
+  return Number(BigInt(result.result));
+}
+function typicalSwapGasUnits(chainId) {
+  switch (chainId) {
+    case 1:
+      return 300000n;
+    // Ethereum mainnet
+    case 137:
+      return 300000n;
+    // Polygon
+    case 56:
+      return 250000n;
+    // BSC
+    case 42161:
+      return 1500000n;
+    // Arbitrum (incl L1 calldata)
+    case 8453:
+    case 10:
+      return 700000n;
+    // Base / Optimism (incl L1 calldata)
+    default:
+      return 300000n;
+  }
+}
+async function estimateEvmGasReserve(rpcUrl, chainId, opts = {}) {
+  const gasUnits = opts.gasUnits ?? typicalSwapGasUnits(chainId);
+  const rawBuffer = opts.bufferBps ?? 15e3;
+  const bufferBps = Math.max(
+    Number.isFinite(rawBuffer) ? Math.round(rawBuffer) : 15e3,
+    1
+  );
+  const gasPrice = await getEvmGasPrice(rpcUrl);
+  const reserveWei = gasPrice * gasUnits * BigInt(bufferBps) / 10000n;
+  return Number((0, import_viem.formatEther)(reserveWei));
+}
+function getChainById(chains, chainId) {
+  return chains.find((chain) => chain.id === chainId);
+}
+function isChainSupported(chains, chainId) {
+  return chains.some((chain) => chain.id === chainId);
+}
+function validateChainConfig(config) {
+  const { defaultChain, supportedChains } = config;
+  if (supportedChains && supportedChains.length === 0) {
+    throw new Error("supportedChains cannot be an empty array");
+  }
+  if (defaultChain && supportedChains) {
+    const isDefaultInSupported = supportedChains.some(
+      (chain) => chain.id === defaultChain.id
+    );
+    if (!isDefaultInSupported) {
+      throw new Error(
+        `defaultChain (${defaultChain.name}, ID: ${defaultChain.id}) must be included in supportedChains`
+      );
+    }
+  }
+}
+function getDefaultChain(config) {
+  if (config.defaultChain) {
+    return config.defaultChain;
+  }
+  if (config.supportedChains && config.supportedChains.length > 0) {
+    return config.supportedChains[0];
+  }
+  return void 0;
+}
+
+// src/lib/ethereum/siwe.ts
+var import_siwe = require("siwe");
+var import_viem2 = require("viem");
+var EthereumSiweMessage = class {
+  constructor({
+    nonce,
+    domain,
+    address,
+    uri,
+    version = "1",
+    chainId = 1,
+    statement,
+    issuedAt,
+    expirationTime,
+    notBefore,
+    requestId,
+    resources
+  }) {
+    this.siweMessage = new import_siwe.SiweMessage({
+      domain,
+      address,
+      uri,
+      version,
+      chainId,
+      nonce,
+      statement,
+      issuedAt,
+      expirationTime,
+      notBefore,
+      requestId,
+      resources
+    });
+  }
+  prepareMessage() {
+    return this.siweMessage.prepareMessage();
+  }
+  getMessage() {
+    return this.siweMessage;
+  }
+};
+function createManualSiweMessage({
+  nonce,
+  domain,
+  address,
+  uri = typeof window !== "undefined" ? window.location.origin : "",
+  version = "1",
+  chainId = 1,
+  statement,
+  issuedAt = (/* @__PURE__ */ new Date()).toISOString(),
+  walletName = "Ethereum"
+}) {
+  let checksummedAddress;
+  try {
+    checksummedAddress = (0, import_viem2.getAddress)(address);
+  } catch (error) {
+    checksummedAddress = address;
+  }
+  let siweMessage = `${domain} wants you to sign in with your Ethereum account:
+`;
+  siweMessage += `${checksummedAddress}`;
+  const defaultStatement = `Sign in with Ethereum to MoonKey using ${walletName}.`;
+  siweMessage += `
+
+${statement || defaultStatement}`;
+  const fields = [];
+  fields.push(`URI: ${uri}`);
+  fields.push(`Version: ${version}`);
+  fields.push(`Chain ID: ${chainId}`);
+  fields.push(`Nonce: ${nonce}`);
+  fields.push(`Issued At: ${issuedAt}`);
+  siweMessage += `
+
+${fields.join("\n")}`;
+  return siweMessage;
+}
+
+// src/lib/ethereum/tx-prep.ts
+var import_viem3 = require("viem");
+function resolveEvmChain({
+  requestedChainId,
+  walletChainId,
+  supportedChains,
+  defaultChain,
+  strict = false
+}) {
+  let target;
+  if (requestedChainId && supportedChains) {
+    target = getChainById(supportedChains, Number(requestedChainId));
+  }
+  if (!target && walletChainId && supportedChains) {
+    target = getChainById(supportedChains, walletChainId);
+  }
+  if (!target) {
+    target = defaultChain;
+  }
+  if (!target) {
+    throw new Error(
+      "No chain configured. Please set ethereum.defaultChain in MoonKeyProvider config."
+    );
+  }
+  if (strict && requestedChainId && Number(requestedChainId) !== target.id) {
+    throw new Error(
+      `Requested chainId ${requestedChainId} is not in the configured supportedChains.`
+    );
+  }
+  return target;
+}
+async function prepareEvmSignTransaction({
+  transaction,
+  wallet,
+  supportedChains,
+  defaultChain
+}) {
+  if (typeof transaction === "string") {
+    return { serializedTransaction: transaction, chain: void 0 };
+  }
+  const txObj = transaction;
+  const transactionType = txObj.type ?? 2;
+  const chain = resolveEvmChain({
+    requestedChainId: txObj.chainId,
+    walletChainId: wallet.chainId,
+    supportedChains,
+    defaultChain,
+    strict: false
+  });
+  const derivedChainId = txObj.chainId || chain.id;
+  const formattedTransaction = {
+    to: txObj.to,
+    value: txObj.value ? typeof txObj.value === "bigint" ? txObj.value : (0, import_viem3.parseEther)(txObj.value.toString()) : BigInt(0),
+    data: txObj.data || "0x",
+    chainId: derivedChainId
+  };
+  if (transactionType === 2 || transactionType === "eip1559") {
+    formattedTransaction.type = "eip1559";
+    formattedTransaction.maxPriorityFeePerGas = txObj.maxPriorityFeePerGas ? typeof txObj.maxPriorityFeePerGas === "bigint" ? txObj.maxPriorityFeePerGas : (0, import_viem3.parseGwei)(txObj.maxPriorityFeePerGas.toString()) : BigInt(2e9);
+    formattedTransaction.maxFeePerGas = txObj.maxFeePerGas ? typeof txObj.maxFeePerGas === "bigint" ? txObj.maxFeePerGas : (0, import_viem3.parseGwei)(txObj.maxFeePerGas.toString()) : BigInt(22e9);
+  } else {
+    formattedTransaction.type = "legacy";
+    formattedTransaction.gasPrice = txObj.gasPrice ? typeof txObj.gasPrice === "bigint" ? txObj.gasPrice : (0, import_viem3.parseGwei)(txObj.gasPrice.toString()) : BigInt(2e9);
+  }
+  if (txObj.nonce !== void 0) {
+    formattedTransaction.nonce = Number(txObj.nonce);
+  }
+  if (txObj.gas !== void 0) {
+    formattedTransaction.gas = typeof txObj.gas === "bigint" ? txObj.gas : BigInt(txObj.gas);
+  }
+  if (txObj.gasLimit !== void 0) {
+    formattedTransaction.gas = typeof txObj.gasLimit === "bigint" ? txObj.gasLimit : BigInt(txObj.gasLimit);
+  }
+  return {
+    serializedTransaction: (0, import_viem3.serializeTransaction)(formattedTransaction),
+    chain
+  };
+}
+async function prepareEvmSendTransaction({
+  transaction,
+  wallet,
+  supportedChains,
+  defaultChain
+}) {
+  const chain = resolveEvmChain({
+    requestedChainId: transaction.chainId,
+    walletChainId: wallet.chainId,
+    supportedChains,
+    defaultChain,
+    strict: true
+  });
+  const rpcUrl = getRpcUrl(chain);
+  if (!rpcUrl) {
+    throw new Error(
+      `No RPC URL found for chain ${chain.name}. Chain may be missing rpcUrls configuration.`
+    );
+  }
+  const txWithChainId = {
+    ...transaction,
+    chainId: chain.id
+  };
+  if (txWithChainId.nonce == null) {
+    try {
+      txWithChainId.nonce = await getEvmNonce(rpcUrl, wallet.public_address);
+    } catch {
+    }
+  }
+  const callerGas = txWithChainId.gas ?? txWithChainId.gasLimit;
+  if (callerGas == null) {
+    try {
+      const estimate = await estimateEvmGas(rpcUrl, {
+        from: wallet.public_address,
+        to: txWithChainId.to,
+        data: txWithChainId.data,
+        value: txWithChainId.value
+      });
+      txWithChainId.gas = (estimate * 12n / 10n).toString();
+    } catch {
+      txWithChainId.gas = "800000";
+    }
+  } else if (callerGas != null && txWithChainId.gas == null) {
+    txWithChainId.gas = callerGas;
+  }
+  if (txWithChainId.maxFeePerGas == null && txWithChainId.gasPrice == null) {
+    try {
+      const [baseGasPrice, suggestedTipResult] = await Promise.all([
+        getEvmGasPrice(rpcUrl),
+        getEvmMaxPriorityFeePerGas(rpcUrl).catch(() => null)
+      ]);
+      let tip;
+      if (suggestedTipResult != null && suggestedTipResult > 0n) {
+        tip = suggestedTipResult * 12n / 10n;
+      } else {
+        const cap = 2000000000n;
+        tip = baseGasPrice / 10n < cap ? baseGasPrice / 10n : cap;
+        if (tip <= 0n) tip = 1n;
+      }
+      const baseMaxFee = baseGasPrice > 0n ? baseGasPrice * 15n / 10n : tip * 2n;
+      const maxFee = baseMaxFee > tip ? baseMaxFee : tip + 1n;
+      txWithChainId.maxFeePerGas = `0x${maxFee.toString(16)}`;
+      txWithChainId.maxPriorityFeePerGas = `0x${tip.toString(16)}`;
+    } catch {
+    }
+  }
+  return { transaction: txWithChainId, rpcUrl, chain };
+}
+
+// src/lib/solana/siws.ts
+var nacl = __toESM(require("tweetnacl"));
+var SiwsMessage = class {
+  constructor({
+    nonce,
+    domain,
+    address,
+    uri,
+    version,
+    chainId,
+    statement,
+    issuedAt,
+    expirationTime,
+    notBefore,
+    requestId,
+    resources,
+    message,
+    signature
+  }) {
+    this.nonce = nonce;
+    this.domain = domain;
+    this.address = address;
+    this.uri = uri;
+    this.version = version;
+    this.chainId = chainId;
+    this.statement = statement;
+    this.issuedAt = issuedAt;
+    this.expirationTime = expirationTime;
+    this.notBefore = notBefore;
+    this.requestId = requestId;
+    this.resources = resources;
+    this.message = message;
+    this.signature = signature;
+  }
+  prepareBasic() {
+    let message = `${this.domain} wants you to sign in with your Solana account:
+`;
+    message += `${this.address}`;
+    if (this.statement) {
+      message += `
+
+${this.statement}`;
+    }
+    const fields = [];
+    if (this.nonce) {
+      fields.push(`Nonce: ${this.nonce}`);
+    }
+    if (this.issuedAt) {
+      fields.push(`Issued At: ${this.issuedAt}`);
+    }
+    if (fields.length) {
+      message += `
+
+${fields.join("\n")}`;
+    }
+    this.message = message;
+    return new TextEncoder().encode(message);
+  }
+  prepareAdvanced() {
+    const issuedAt = this.issuedAt || (/* @__PURE__ */ new Date()).toISOString();
+    let message = `${this.domain} wants you to sign in with your Solana account:
+`;
+    message += `${this.address}`;
+    if (this.statement) {
+      message += `
+
+${this.statement}`;
+    }
+    const fields = [];
+    if (this.uri) {
+      fields.push(`URI: ${this.uri}`);
+    }
+    if (this.version) {
+      fields.push(`Version: ${this.version}`);
+    }
+    if (this.chainId) {
+      fields.push(`Chain ID: ${this.chainId}`);
+    }
+    if (this.nonce) {
+      fields.push(`Nonce: ${this.nonce}`);
+    }
+    if (this.issuedAt) {
+      fields.push(`Issued At: ${this.issuedAt}`);
+    }
+    if (this.expirationTime) {
+      fields.push(`Expiration Time: ${this.expirationTime}`);
+    }
+    if (this.notBefore) {
+      fields.push(`Not Before: ${this.notBefore}`);
+    }
+    if (this.requestId) {
+      fields.push(`Request ID: ${this.requestId}`);
+    }
+    if (this.resources && this.resources.length > 0) {
+      fields.push(`Resources:`);
+      for (const resource of this.resources) {
+        fields.push(`- ${resource}`);
+      }
+    }
+    if (fields.length) {
+      message += `
+
+${fields.join("\n")}`;
+    }
+    this.message = message;
+    return new TextEncoder().encode(message);
+  }
+  async token(signature) {
+    const bs58 = await import("bs58");
+    this.signature = bs58.default.encode(signature);
+    const tokenData = Buffer.from(JSON.stringify(this));
+    return tokenData.toString("base64");
+  }
+  decode(token) {
+    const tokenObject = Buffer.from(token, "base64");
+    const siwsMessage = JSON.parse(tokenObject.toString("utf8"));
+    this.nonce = siwsMessage.nonce;
+    this.domain = siwsMessage.domain;
+    this.address = siwsMessage.address;
+    this.uri = siwsMessage.uri;
+    this.version = siwsMessage.version;
+    this.chainId = siwsMessage.chainId;
+    this.statement = siwsMessage.statement;
+    this.issuedAt = siwsMessage.issuedAt;
+    this.expirationTime = siwsMessage.expirationTime;
+    this.notBefore = siwsMessage.notBefore;
+    this.requestId = siwsMessage.requestId;
+    this.resources = siwsMessage.resources;
+    this.signature = siwsMessage.signature;
+    this.message = siwsMessage.message;
+    return this;
+  }
+  async validate() {
+    if (!this.message || !this.signature) {
+      return false;
+    }
+    const bs58 = await import("bs58");
+    const messageBytes = new TextEncoder().encode(this.message);
+    const publicKeyBytes = bs58.default.decode(this.address);
+    const signatureBytes = bs58.default.decode(this.signature);
+    const result = nacl.sign.detached.verify(
+      messageBytes,
+      signatureBytes,
+      publicKeyBytes
+    );
+    return result;
+  }
+};
+
+// src/lib/solana/transaction-log-parser.ts
+var import_web3 = require("@solana/web3.js");
+var import_bn = __toESM(require("bn.js"));
+var base64ToUint8Array = (base64) => {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+};
+var SolanaTransactionParser = class {
+  constructor(logs, base64Transaction, connection, userPublicKey) {
+    this.instructions = [];
+    this.logs = logs;
+    this.connection = connection;
+    this.userPublicKey = userPublicKey;
+    if (base64Transaction) {
+      try {
+        const txBuffer = base64ToUint8Array(base64Transaction);
+        try {
+          this.transaction = import_web3.VersionedTransaction.deserialize(txBuffer);
+        } catch {
+          this.transaction = import_web3.Transaction.from(txBuffer);
+        }
+      } catch (e) {
+        console.error("Failed to deserialize transaction:", e);
+      }
+    }
+  }
+  async parse() {
+    if (!this.transaction) {
+      throw new Error("No transaction provided. Pass base64 transaction string to constructor.");
+    }
+    this.instructions = [];
+    const message = this.transaction instanceof import_web3.VersionedTransaction ? this.transaction.message : this.transaction.compileMessage();
+    const accountKeys = "staticAccountKeys" in message ? message.staticAccountKeys : message.accountKeys;
+    const compiledInstructions = "compiledInstructions" in message ? message.compiledInstructions : message.instructions;
+    for (let i = 0; i < compiledInstructions.length; i++) {
+      const ix = compiledInstructions[i];
+      const programId = accountKeys[ix.programIdIndex];
+      const programIdStr = programId.toBase58();
+      const ixAccounts = ix.accountKeyIndexes.map((idx) => accountKeys[idx]);
+      const data = ix.data instanceof Uint8Array ? ix.data : new Uint8Array(ix.data);
+      await this.parseInstruction(programIdStr, data, ixAccounts, i);
+    }
+    return this.instructions;
+  }
+  async parseInstruction(programId, data, accounts, instructionIndex) {
+    switch (programId) {
+      case "ComputeBudget11111111111111111111111111111111":
+        this.parseComputeBudget(data);
+        break;
+      case "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL":
+        this.parseAssociatedToken(accounts);
+        break;
+      case "11111111111111111111111111111111":
+        this.parseSystemProgram(data, accounts);
+        break;
+      case "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA":
+        this.parseTokenProgram(data, accounts);
+        break;
+      case "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4":
+        break;
+      default:
+        this.parseGenericInstruction(programId, data, accounts, instructionIndex);
+        break;
+    }
+  }
+  parseGenericInstruction(programId, data, accounts, instructionIndex) {
+    const instructionType = data.length > 0 ? data[0] : 0;
+    this.instructions.push({
+      type: "Unknown",
+      details: {
+        programId: this.truncate(programId, 8, 4),
+        instructionType,
+        dataLength: data.length,
+        rawData: data.toString("hex"),
+        accountCount: accounts.length,
+        accounts: accounts.map((acc) => this.truncate(acc.toBase58(), 5, 4))
+      }
+    });
+  }
+  parseComputeBudget(data) {
+    const instructionType = data[0];
+    this.instructions.push({
+      type: "ComputeBudget",
+      details: {
+        programId: this.truncate("ComputeBudget11111111111111111111111111111111", 8, 4),
+        data: instructionType
+      }
+    });
+  }
+  parseAssociatedToken(accounts) {
+    const owner = accounts[2];
+    this.instructions.push({
+      type: "CreateTokenAccount",
+      details: {
+        programId: this.truncate("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", 5, 4),
+        owner: this.truncate(owner?.toBase58() || "Unknown", 5, 4)
+      }
+    });
+  }
+  parseSystemProgram(data, accounts) {
+    const instructionType = data.readUInt32LE(0);
+    if (instructionType === 2) {
+      const lamports = new import_bn.default(data.slice(4, 12), "le");
+      const destination = accounts[1];
+      this.instructions.push({
+        type: "Transfer",
+        details: {
+          amount: this.formatSOL(lamports.toString()),
+          destination: this.truncate(destination?.toBase58() || "Unknown", 5, 4)
+        }
+      });
+    }
+  }
+  parseTokenProgram(data, accounts) {
+    const instructionType = data[0];
+    if (instructionType === 17) {
+      this.instructions.push({
+        type: "SyncNative",
+        details: {
+          programId: this.truncate("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", 5, 4)
+        }
+      });
+    } else if (instructionType === 9) {
+      const source = accounts[0];
+      const destination = accounts[1];
+      const owner = accounts[2];
+      this.instructions.push({
+        type: "CloseAccount",
+        details: {
+          source: this.truncate(source?.toBase58() || "Unknown", 5, 4),
+          destination: this.truncate(destination?.toBase58() || "Unknown", 5, 4),
+          owner: this.truncate(owner?.toBase58() || "Unknown", 5, 4)
+        }
+      });
+    }
+  }
+  parseJupiterBasic(data, accounts) {
+    let inAmount = "Unknown";
+    let outAmount = "Unknown";
+    let tokenIn = "Unknown";
+    let tokenOut = "Unknown";
+    for (const log of this.logs) {
+      if (log.includes("Transfer") && log.includes("lamports")) {
+        const lamportsMatch = log.match(/(\d+)\s*lamports/);
+        if (lamportsMatch && inAmount === "Unknown") {
+          inAmount = this.formatSOL(lamportsMatch[1]);
+        }
+      }
+      if (log.includes("amount:") || log.includes("Amount:")) {
+        const amountMatch = log.match(/amount:\s*(\d+)/i);
+        if (amountMatch) {
+          if (inAmount === "Unknown") {
+            inAmount = amountMatch[1];
+          } else if (outAmount === "Unknown") {
+            outAmount = amountMatch[1];
+          }
+        }
+      }
+      if (log.includes("mint:") || log.includes("Mint:") || log.includes("mint=")) {
+        const mintMatch = log.match(/(?:mint:|Mint:|mint=)\s*([A-Za-z0-9]{32,44})/i);
+        if (mintMatch) {
+          const mintAddress = mintMatch[1];
+          if (tokenIn === "Unknown") {
+            tokenIn = this.truncate(mintAddress, 5, 4);
+          } else if (tokenOut === "Unknown") {
+            tokenOut = this.truncate(mintAddress, 5, 4);
+          }
+        }
+      }
+      if (log.includes("Program return: JUP6")) {
+        const match = log.match(/Program return: \S+ (.+)/);
+        if (match) {
+          try {
+            const decoded = base64ToUint8Array(match[1]);
+            outAmount = new import_bn.default(decoded, "le").toString();
+          } catch (e) {
+            console.error("Failed to decode Jupiter return:", e);
+          }
+        }
+      }
+    }
+    if (tokenIn === "Unknown" || tokenOut === "Unknown") {
+      const wsolMint = "So11111111111111111111111111111111111111112";
+      for (const account of accounts) {
+        try {
+          const accountStr = account.toBase58();
+          if (!accountStr.includes("11111111111111111111111111111111") && !accountStr.includes("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") && !accountStr.includes("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL") && !accountStr.includes("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4")) {
+            if (tokenIn === "Unknown") {
+              tokenIn = this.truncate(accountStr, 5, 4);
+            } else if (tokenOut === "Unknown") {
+              tokenOut = this.truncate(accountStr, 5, 4);
+              break;
+            }
+          }
+        } catch (e) {
+        }
+      }
+      if (tokenIn === "Unknown") {
+        tokenIn = this.truncate(wsolMint, 5, 4);
+      }
+    }
+    this.instructions.push({
+      type: "JupiterSwap",
+      details: {
+        inAmount,
+        outAmount,
+        tokenIn,
+        tokenOut
+      }
+    });
+  }
+  parseTokenAccountData(data) {
+    try {
+      if (data.length < 146) {
+        throw new Error(`Invalid token account data length: ${data.length}`);
+      }
+      const mint = new import_web3.PublicKey(data.slice(0, 32));
+      const owner = new import_web3.PublicKey(data.slice(32, 64));
+      const amount = new import_bn.default(data.slice(64, 72), "le");
+      const delegate = data.slice(72, 104).every((b) => b === 0) ? null : new import_web3.PublicKey(data.slice(72, 104));
+      const state = data[104];
+      const isNative = data[105] === 1;
+      const delegatedAmount = new import_bn.default(data.slice(106, 114), "le");
+      const closeAuthority = data.slice(114, 146).every((b) => b === 0) ? null : new import_web3.PublicKey(data.slice(114, 146));
+      return {
+        mint,
+        owner,
+        amount,
+        delegate,
+        state,
+        isNative,
+        delegatedAmount,
+        closeAuthority
+      };
+    } catch (error) {
+      console.error("Error parsing token account data:", error);
+      throw error;
+    }
+  }
+  formatTokenAmount(amount, mint) {
+    const wsolMint = "So11111111111111111111111111111111111111112";
+    if (mint.toBase58() === wsolMint) {
+      return this.formatSOL(amount.toString());
+    }
+    return amount.toString();
+  }
+  formatSOL(lamports) {
+    try {
+      const bn = new import_bn.default(lamports);
+      const divisor = new import_bn.default(1e9);
+      const sol = bn.div(divisor);
+      const remainder = bn.mod(divisor);
+      const decStr = remainder.toString().padStart(9, "0");
+      const trimmed = decStr.replace(/0+$/, "");
+      if (trimmed.length === 0) {
+        return `${sol.toString()} SOL`;
+      }
+      return `${sol.toString()}.${trimmed} SOL`;
+    } catch {
+      return `${lamports} lamports`;
+    }
+  }
+  truncate(address, start = 5, end = 4) {
+    if (!address || address.length <= start + end) return address;
+    return `${address.slice(0, start)}...${address.slice(-end)}`;
+  }
+  getInstructions() {
+    return this.instructions;
+  }
+  getInstructionsByType(type) {
+    return this.instructions.filter((i) => i.type === type);
+  }
+};
+async function getInstructionsForHTML(base64Transaction, logs, connection, userPublicKey) {
+  const parser = new SolanaTransactionParser(logs, base64Transaction, connection, userPublicKey);
+  const instructions = await parser.parse();
+  return instructions.map((instruction, index) => {
+    const details = [];
+    switch (instruction.type) {
+      case "ComputeBudget":
+        details.push(
+          { label: "Program ID", value: instruction.details.programId },
+          { label: "Data", value: instruction.details.data.toString() }
+        );
+        return {
+          id: `${instruction.type}-${index}`,
+          type: instruction.type,
+          title: "",
+          details
+        };
+      case "CreateTokenAccount":
+        details.push(
+          { label: "Program ID", value: instruction.details.programId },
+          { label: "Owner", value: instruction.details.owner }
+        );
+        return {
+          id: `${instruction.type}-${index}`,
+          type: instruction.type,
+          title: "Create token account",
+          details
+        };
+      case "Transfer":
+        details.push(
+          { label: "Amount", value: instruction.details.amount },
+          { label: "Destination", value: instruction.details.destination }
+        );
+        return {
+          id: `${instruction.type}-${index}`,
+          type: instruction.type,
+          title: "Transfer",
+          details
+        };
+      case "SyncNative":
+        details.push(
+          { label: "Program ID", value: instruction.details.programId }
+        );
+        return {
+          id: `${instruction.type}-${index}`,
+          type: instruction.type,
+          title: "Sync native",
+          details
+        };
+      case "JupiterSwap":
+        details.push(
+          { label: "in amount", value: instruction.details.inAmount },
+          { label: "out amount", value: instruction.details.outAmount },
+          { label: "Token in", value: instruction.details.tokenIn },
+          { label: "Token out", value: instruction.details.tokenOut }
+        );
+        return {
+          id: `${instruction.type}-${index}`,
+          type: instruction.type,
+          title: "Jupiter swap",
+          details
+        };
+      case "CloseAccount":
+        details.push(
+          { label: "Source", value: instruction.details.source },
+          { label: "Destination", value: instruction.details.destination },
+          { label: "Owner", value: instruction.details.owner }
+        );
+        return {
+          id: `${instruction.type}-${index}`,
+          type: instruction.type,
+          title: "Close token account",
+          details
+        };
+      case "Unknown":
+        details.push(
+          { label: "Program ID", value: instruction.details.programId },
+          { label: "Instruction Type", value: instruction.details.instructionType.toString() },
+          { label: "Data Length", value: instruction.details.dataLength.toString() },
+          { label: "Account Count", value: instruction.details.accountCount.toString() },
+          { label: "Raw Data", value: instruction.details.rawData },
+          { label: "Accounts", value: instruction.details.accounts.join(", ") }
+        );
+        return {
+          id: `${instruction.type}-${index}`,
+          type: instruction.type,
+          title: "Unknown instruction",
+          details
+        };
+      default:
+        return {
+          id: `${instruction.type}-${index}`,
+          type: instruction.type,
+          title: instruction.type,
+          details: Object.entries(instruction.details).map(([key, value]) => ({
+            label: key,
+            value: String(value)
+          }))
+        };
+    }
+  });
+}
+async function getTransferInfoFromInstructions(base64Transaction, logs, solPriceUsd) {
+  const transfers = [];
+  try {
+    const parser = new SolanaTransactionParser(logs, base64Transaction);
+    const instructions = await parser.parse();
+    for (const instruction of instructions) {
+      if (instruction.type === "Transfer") {
+        let usdValue;
+        if (solPriceUsd && instruction.details.amount.includes("SOL")) {
+          const solAmountMatch = instruction.details.amount.match(/(\d+(?:\.\d+)?)\s*SOL/);
+          if (solAmountMatch) {
+            const solAmount = parseFloat(solAmountMatch[1]);
+            const usdPrice = parseFloat(solPriceUsd);
+            const usdAmount = solAmount * usdPrice;
+            usdValue = `$${usdAmount.toFixed(2)}`;
+          }
+        }
+        transfers.push({
+          amount: instruction.details.amount,
+          destination: instruction.details.destination,
+          type: "SOL",
+          usdValue
+        });
+      } else if (instruction.type === "JupiterSwap") {
+        if (instruction.details.inAmount && instruction.details.outAmount) {
+          let usdValue;
+          if (solPriceUsd && instruction.details.inAmount.includes("SOL")) {
+            const solAmountMatch = instruction.details.inAmount.match(/(\d+(?:\.\d+)?)\s*SOL/);
+            if (solAmountMatch) {
+              const solAmount = parseFloat(solAmountMatch[1]);
+              const usdPrice = parseFloat(solPriceUsd);
+              const usdAmount = solAmount * usdPrice;
+              usdValue = `$${usdAmount.toFixed(2)}`;
+            }
+          }
+          transfers.push({
+            amount: instruction.details.inAmount,
+            destination: "Jupiter Swap",
+            type: "SOL",
+            usdValue
+          });
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error parsing instructions for transfers:", error);
+  }
+  return transfers;
+}
+async function getSOLTransfersFromInstructions(base64Transaction, logs, solPriceUsd) {
+  const transfers = [];
+  try {
+    const parser = new SolanaTransactionParser(logs, base64Transaction);
+    const instructions = await parser.parse();
+    for (const instruction of instructions) {
+      if (instruction.type === "Transfer") {
+        const amountStr = instruction.details.amount;
+        const lamportsMatch = amountStr.match(/(\d+(?:\.\d+)?)\s*SOL/);
+        const lamports = lamportsMatch ? Math.floor(parseFloat(lamportsMatch[1]) * 1e9).toString() : "0";
+        let usdValue;
+        if (solPriceUsd && lamportsMatch) {
+          const solAmount = parseFloat(lamportsMatch[1]);
+          const usdPrice = parseFloat(solPriceUsd);
+          const usdAmount = solAmount * usdPrice;
+          usdValue = `$${usdAmount.toFixed(2)}`;
+        }
+        transfers.push({
+          amount: instruction.details.amount,
+          destination: instruction.details.destination,
+          lamports,
+          usdValue
+        });
+      }
+    }
+  } catch (error) {
+    console.error("Error parsing instructions for SOL transfers:", error);
+  }
+  return transfers;
+}
+
+// src/lib/build-url.ts
+var buildUrl = (baseUrl, sdkConfig, enableCaptcha, captchaSitekey) => {
+  if (!sdkConfig.publishableKey) {
+    throw new Error("MoonKey SDK Error: Publishable Key is required");
+  }
+  if (!baseUrl || typeof baseUrl !== "string" || baseUrl === "null" || baseUrl === "undefined") {
+    console.error("Invalid baseUrl:", baseUrl);
+    throw new Error(
+      `MoonKey SDK Error: Invalid base URL provided: "${baseUrl}"`
+    );
+  }
+  if (typeof window === "undefined") {
+    const params = new URLSearchParams();
+    params.append("publishableKey", sdkConfig.publishableKey);
+    const hideClose = sdkConfig.config?.appearance?.hideClose;
+    if (hideClose === true) {
+      params.append("hideClose", "true");
+    }
+    if (enableCaptcha) {
+      params.append("enableCaptcha", "true");
+    }
+    if (captchaSitekey) {
+      params.append("captchaSitekey", captchaSitekey);
+    }
+    return `${baseUrl}?${params.toString()}`;
+  }
+  try {
+    const url = new URL(baseUrl);
+    url.searchParams.append("publishableKey", sdkConfig.publishableKey);
+    const hideClose = sdkConfig.config?.appearance?.hideClose;
+    if (hideClose === true) {
+      url.searchParams.append("hideClose", "true");
+    }
+    if (enableCaptcha) {
+      url.searchParams.append("enableCaptcha", "true");
+    }
+    if (captchaSitekey) {
+      url.searchParams.append("captchaSitekey", captchaSitekey);
+    }
+    return url.toString();
+  } catch (error) {
+    throw new Error(
+      `MoonKey SDK Error: Invalid base URL "${baseUrl}": ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+};
+
+// src/lib/constants.ts
+var DEFAULT_AUTH_URL = "https://iframe.moonx-dev.com";
+
+// src/lib/rpc-broadcast.ts
+var serializeEthereumTransaction = async (transaction) => {
+  if (typeof transaction === "string") {
+    return transaction;
+  }
+  if (!transaction || typeof transaction !== "object") {
+    throw new Error("ethereum_transaction_invalid");
+  }
+  const { serializeTransaction: serializeTransaction2, parseEther: parseEther3, parseGwei: parseGwei2 } = await import("viem");
+  const toWei = (val, humanUnit) => {
+    if (val == null || val === "") return BigInt(0);
+    if (typeof val === "bigint") return val;
+    if (typeof val === "number") return BigInt(val);
+    if (typeof val === "string") {
+      if (val.startsWith("0x")) return BigInt(val);
+      if (val.includes(".")) {
+        return humanUnit === "ether" ? parseEther3(val) : parseGwei2(val);
+      }
+      return BigInt(val);
+    }
+    return BigInt(val);
+  };
+  const formatted = {
+    to: transaction.to,
+    value: toWei(transaction.value, "ether"),
+    data: transaction.data || "0x",
+    chainId: transaction.chainId || 1,
+    type: "eip1559",
+    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? toWei(transaction.maxPriorityFeePerGas, "gwei") : BigInt(2e9),
+    maxFeePerGas: transaction.maxFeePerGas ? toWei(transaction.maxFeePerGas, "gwei") : BigInt(22e9),
+    ...transaction.nonce && { nonce: Number(transaction.nonce) },
+    ...transaction.gas && { gas: BigInt(transaction.gas) }
+  };
+  return serializeTransaction2(formatted);
+};
+var broadcastEthereumRaw = async (rpcUrl, signedSerialized) => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 3e4);
+  try {
+    const response = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "eth_sendRawTransaction",
+        params: [signedSerialized]
+      }),
+      signal: controller.signal
+    });
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error.message || "eth_sendRawTransaction failed");
+    }
+    return result.result;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error("RPC request timed out after 30 seconds");
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+};
+var broadcastSolanaSigned = async (rpcUrl, signedBase58) => {
+  const { default: bs58 } = await import("bs58");
+  const transactionBytes = bs58.decode(signedBase58);
+  const base64Transaction = Buffer.from(transactionBytes).toString("base64");
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [
+        base64Transaction,
+        {
+          encoding: "base64",
+          skipPreflight: false,
+          preflightCommitment: "confirmed",
+          maxRetries: 3
+        }
+      ]
+    })
+  });
+  const result = await response.json();
+  if (result.error) {
+    throw new Error(`Solana RPC error: ${result.error.message}`);
+  }
+  return result.result;
+};
+
+// src/lib/wire-codec.ts
+var arrayLikeToBytes = (value) => {
+  if (value instanceof Uint8Array) return value;
+  if (Array.isArray(value)) return new Uint8Array(value);
+  if (value && typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length === 0) return new Uint8Array();
+    if (keys.every((k) => /^\d+$/.test(k))) {
+      const len = keys.length;
+      const out = new Uint8Array(len);
+      for (let i = 0; i < len; i++) {
+        out[i] = value[String(i)] ?? 0;
+      }
+      return out;
+    }
+  }
+  throw new Error(`arrayLikeToBytes: unsupported shape (${typeof value})`);
+};
+var bs58ToBytes = async (value) => {
+  if (value instanceof Uint8Array) return value;
+  if (Array.isArray(value)) return new Uint8Array(value);
+  if (typeof value === "string") {
+    const { default: bs58 } = await import("bs58");
+    return bs58.decode(value);
+  }
+  return arrayLikeToBytes(value);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_AUTH_URL,
+  EthereumSiweMessage,
+  SiwsMessage,
+  SolanaTransactionParser,
+  arrayLikeToBytes,
+  authState,
+  broadcastEthereumRaw,
+  broadcastSolanaSigned,
+  bs58ToBytes,
+  buildUrl,
+  clearParentAssertCache,
+  createManualSiweMessage,
+  estimateEvmGas,
+  estimateEvmGasReserve,
+  formatPasskeyLabel,
+  fromB64url,
+  generatePasskeyUserId,
+  getAssertCacheTtlMs,
+  getChainById,
+  getDefaultChain,
+  getEvmGasPrice,
+  getEvmMaxPriorityFeePerGas,
+  getEvmNonce,
+  getInstructionsForHTML,
+  getRpcUrl,
+  getSOLTransfersFromInstructions,
+  getTransferInfoFromInstructions,
+  isChainSupported,
+  prepareEvmSendTransaction,
+  prepareEvmSignTransaction,
+  readParentAssertCache,
+  resolveEvmChain,
+  resolvePasskeyMetadata,
+  sanitizeUserData,
+  serializeEthereumTransaction,
+  setAssertCacheTtlMs,
+  setChainRpcUrl,
+  toB64url,
+  validateChainConfig,
+  verifyIdToken,
+  withClearOnFailure,
+  writeParentAssertCache
+});