@bit-buccaneers/wallet-abstraction 0.0.1

package/dist/dev.js

@@ -0,0 +1,1287 @@
+import { injected, metaMask, coinbaseWallet } from '@wagmi/connectors';
+import { createConfig, getConnectors, signMessage, disconnect, connect, watchConnections } from '@wagmi/core';
+import { http } from 'viem';
+import { mainnet } from 'viem/chains';
+import bs58 from 'bs58';
+import nacl from 'tweetnacl';
+import { SignClient } from '@walletconnect/sign-client';
+import { isWalletAdapterCompatibleStandardWallet } from '@solana/wallet-adapter-base';
+import { getWallets } from '@wallet-standard/app';
+import { createComponent } from 'solid-js/web';
+import { createContext, useContext, createSignal, onMount, onCleanup } from 'solid-js';
+
+// src/lib/evm/config.ts
+var config = null;
+var configuredChains = [mainnet];
+var createEvmConfig = (chains) => {
+  if (chains) configuredChains = chains;
+  const connectors = [injected(), metaMask(), coinbaseWallet({ appName: "Wallet Abstraction" })];
+  const transports = {};
+  for (const chain of configuredChains) {
+    transports[chain.id] = http();
+  }
+  config = createConfig({
+    chains: configuredChains,
+    connectors,
+    transports
+  });
+  return config;
+};
+var getEvmConfig = () => {
+  if (!config) config = createEvmConfig();
+  return config;
+};
+
+// src/lib/core/constants.ts
+var STORAGE_KEYS = {
+  SOLANA_WALLET: "wallet-abstraction:solana-wallet"
+};
+
+// src/lib/core/helpers.ts
+var connectedResult = (address, options) => ({
+  status: "connected",
+  address,
+  chainId: options?.chainId,
+  publicKey: options?.publicKey
+});
+var qrcodeResult = (uri, wait) => ({
+  status: "qrcode",
+  uri,
+  wait
+});
+var pendingResult = () => ({ status: "pending" });
+
+// src/lib/core/storage.ts
+var storage = {
+  get: (key) => {
+    try {
+      const value = window.localStorage.getItem(key);
+      return value ? JSON.parse(value) : null;
+    } catch {
+      return null;
+    }
+  },
+  getString: (key) => {
+    return window.localStorage.getItem(key);
+  },
+  set: (key, value) => {
+    window.localStorage.setItem(key, JSON.stringify(value));
+  },
+  setString: (key, value) => {
+    window.localStorage.setItem(key, value);
+  },
+  remove: (key) => {
+    window.localStorage.removeItem(key);
+  },
+  has: (key) => {
+    return window.localStorage.getItem(key) !== null;
+  }
+};
+
+// src/lib/core/utils.ts
+var addFallbackConnectors = (connectors, fallbacks) => {
+  for (const { id, create } of fallbacks) {
+    if (!connectors.some((c) => c.id === id)) {
+      connectors.push(create());
+    }
+  }
+};
+
+// src/lib/wallets/config.ts
+var WALLETS = [
+  { id: "metamask", name: "MetaMask" },
+  { id: "phantom", name: "Phantom" },
+  { id: "okx", name: "OKX Wallet" },
+  { id: "coinbase", name: "Coinbase Wallet" },
+  { id: "binance", name: "Binance Wallet" },
+  { id: "bitget", name: "Bitget Wallet" },
+  { id: "solflare", name: "Solflare" },
+  { id: "trust", name: "Trust Wallet" },
+  { id: "rabby", name: "Rabby" },
+  { id: "rainbow", name: "Rainbow" },
+  { id: "exodus", name: "Exodus" }
+];
+
+// src/lib/wallets/mappers.ts
+var EVM_WALLET_ID_MAP = {
+  "app.phantom": "phantom",
+  "app.backpack": "backpack",
+  "com.trustwallet.app": "trust",
+  "com.binance.wallet": "binance",
+  "com.bitget.web3": "bitget",
+  "com.okex.wallet": "okx",
+  metaMaskSDK: "metamask",
+  coinbaseWalletSDK: "coinbase",
+  "io.rabby": "rabby",
+  "me.rainbow": "rainbow",
+  "com.exodus.wallet": "exodus",
+  walletConnect: "walletconnect"
+};
+var SOLANA_WALLET_ID_MAP = {
+  "binance-wallet": "binance",
+  "bitget-wallet": "bitget",
+  "okx-wallet": "okx",
+  "exodus-wallet": "exodus"
+};
+var normalizeEvmWalletId = (id) => EVM_WALLET_ID_MAP[id] || id.toLowerCase().replace(/sdk$/i, "");
+var normalizeSolanaWalletId = (id) => SOLANA_WALLET_ID_MAP[id] || id.replace(/-wallet$/, "");
+
+// src/lib/connectors/shared/constants.ts
+var WC_CHAINS = {
+  EVM_MAINNET: "eip155:1",
+  SOLANA_MAINNET: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+};
+var WC_METHODS = {
+  EVM: ["eth_sendTransaction", "personal_sign", "eth_signTypedData"],
+  SOLANA: ["solana_signTransaction", "solana_signMessage"]
+};
+var WC_EVENTS = {
+  EVM: ["chainChanged", "accountsChanged"],
+  SOLANA: []
+};
+var EVM_WC_CONFIG = {
+  chains: [WC_CHAINS.EVM_MAINNET],
+  methods: WC_METHODS.EVM,
+  events: WC_EVENTS.EVM
+};
+var SOLANA_WC_CONFIG = {
+  chains: [WC_CHAINS.SOLANA_MAINNET],
+  methods: WC_METHODS.SOLANA,
+  events: WC_EVENTS.SOLANA
+};
+var getDappKeyPair = (storageKey) => {
+  const stored = storage.get(storageKey);
+  if (stored) {
+    return {
+      publicKey: new Uint8Array(stored.publicKey),
+      secretKey: new Uint8Array(stored.secretKey)
+    };
+  }
+  const keyPair = nacl.box.keyPair();
+  storage.set(storageKey, {
+    publicKey: Array.from(keyPair.publicKey),
+    secretKey: Array.from(keyPair.secretKey)
+  });
+  return keyPair;
+};
+var buildConnectUrl = (config2, params) => {
+  const keyPair = getDappKeyPair(`${config2.storageKeyPrefix}_keypair`);
+  const url = new URL(config2.connectUrl);
+  url.searchParams.set("app_url", params.appUrl);
+  url.searchParams.set("dapp_encryption_public_key", bs58.encode(keyPair.publicKey));
+  url.searchParams.set("redirect_link", params.redirectUrl);
+  if (params.cluster) {
+    url.searchParams.set("cluster", params.cluster);
+  }
+  if (params.chain) {
+    url.searchParams.set("chain", params.chain);
+  }
+  return url.toString();
+};
+var parseConnectResponse = (urlParams, config2) => {
+  const walletPublicKey = urlParams.get(config2.encryptionKeyParam);
+  const nonce = urlParams.get("nonce");
+  const data = urlParams.get("data");
+  if (!walletPublicKey || !nonce || !data) {
+    return null;
+  }
+  try {
+    const keyPair = getDappKeyPair(`${config2.storageKeyPrefix}_keypair`);
+    const sharedSecret = nacl.box.before(bs58.decode(walletPublicKey), keyPair.secretKey);
+    const decrypted = nacl.box.open.after(bs58.decode(data), bs58.decode(nonce), sharedSecret);
+    if (!decrypted) {
+      return null;
+    }
+    const response = JSON.parse(new TextDecoder().decode(decrypted));
+    return {
+      publicKey: response.public_key,
+      session: response.session,
+      sharedSecret
+    };
+  } catch {
+    return null;
+  }
+};
+var isWalletResponse = (urlParams, encryptionKeyParam) => urlParams.has(encryptionKeyParam) && urlParams.has("data");
+var handleMobileCallback = (config2, pendingKey, sessionKey) => {
+  const params = new URLSearchParams(window.location.search);
+  if (!params.has(config2.callbackParam) || !isWalletResponse(params, config2.encryptionKeyParam)) {
+    return null;
+  }
+  if (storage.getString(pendingKey) !== "1") return null;
+  const session = parseConnectResponse(params, config2);
+  if (!session) {
+    storage.remove(pendingKey);
+    return null;
+  }
+  const storedSession = {
+    publicKey: session.publicKey,
+    session: session.session,
+    sharedSecret: Array.from(session.sharedSecret)
+  };
+  storage.set(sessionKey, storedSession);
+  storage.remove(pendingKey);
+  window.history.replaceState({}, "", window.location.pathname);
+  return connectedResult(session.publicKey);
+};
+var restoreMobileSession = (sessionKey) => {
+  const session = storage.get(sessionKey);
+  if (!session) return null;
+  return connectedResult(session.publicKey);
+};
+var getStoredSession = (sessionKey) => {
+  return storage.get(sessionKey);
+};
+var buildSignMessageUrl = (signUrl, config2, sessionKey, message, redirectUrl) => {
+  const session = getStoredSession(sessionKey);
+  if (!session) return null;
+  const keyPair = getDappKeyPair(`${config2.storageKeyPrefix}_keypair`);
+  const sharedSecret = new Uint8Array(session.sharedSecret);
+  const payload = {
+    message: bs58.encode(new TextEncoder().encode(message)),
+    session: session.session,
+    display: "utf8"
+  };
+  const nonce = nacl.randomBytes(24);
+  const encrypted = nacl.box.after(
+    new TextEncoder().encode(JSON.stringify(payload)),
+    nonce,
+    sharedSecret
+  );
+  const url = new URL(signUrl);
+  url.searchParams.set("dapp_encryption_public_key", bs58.encode(keyPair.publicKey));
+  url.searchParams.set("nonce", bs58.encode(nonce));
+  url.searchParams.set("redirect_link", redirectUrl);
+  url.searchParams.set("payload", bs58.encode(encrypted));
+  return url.toString();
+};
+var parseSignMessageResponse = (config2, sessionKey) => {
+  const params = new URLSearchParams(window.location.search);
+  const nonce = params.get("nonce");
+  const data = params.get("data");
+  if (!nonce || !data) return null;
+  const session = getStoredSession(sessionKey);
+  if (!session) return null;
+  try {
+    const sharedSecret = new Uint8Array(session.sharedSecret);
+    const decrypted = nacl.box.open.after(bs58.decode(data), bs58.decode(nonce), sharedSecret);
+    if (!decrypted) return null;
+    const response = JSON.parse(new TextDecoder().decode(decrypted));
+    return response.signature;
+  } catch {
+    return null;
+  }
+};
+var connectEvmInjected = async () => {
+  if (!window.ethereum) throw new Error("No injected EVM provider");
+  const accounts = await window.ethereum.request({
+    method: "eth_requestAccounts"
+  });
+  if (!accounts[0]) throw new Error("No accounts returned");
+  const chainId = await window.ethereum.request({ method: "eth_chainId" });
+  return connectedResult(accounts[0], { chainId: parseInt(chainId, 16) });
+};
+var connectSolanaInjected = async () => {
+  if (!window.solana) throw new Error("No injected Solana provider");
+  const response = await window.solana.connect();
+  const publicKey = response.publicKey;
+  return connectedResult(publicKey.toBase58(), { publicKey: publicKey.toBytes() });
+};
+var signSolanaInjected = async (message) => {
+  if (!window.solana?.signMessage) {
+    throw new Error("No injected Solana provider or signMessage not supported");
+  }
+  const encodedMessage = new TextEncoder().encode(message);
+  const result = await window.solana.signMessage(encodedMessage, "utf8");
+  return bs58.encode(new Uint8Array(result.signature));
+};
+
+// src/lib/connectors/shared/parsers.ts
+var parseEvmAccount = (account) => {
+  const [, chainIdStr, address] = account.split(":");
+  if (!address) throw new Error("Invalid EVM account format");
+  return connectedResult(address, { chainId: parseInt(chainIdStr, 10) });
+};
+var parseSolanaAccount = async (account) => {
+  const address = account.split(":")[2];
+  if (!address) throw new Error("Invalid Solana account format");
+  const { default: bs586 } = await import('bs58');
+  return connectedResult(address, { publicKey: bs586.decode(address) });
+};
+var getEvmAccountFromSession = (namespaces) => {
+  const account = namespaces.eip155?.accounts?.[0];
+  if (!account) throw new Error("No EVM accounts returned");
+  return parseEvmAccount(account);
+};
+var getSolanaAccountFromSession = async (namespaces) => {
+  const account = namespaces.solana?.accounts?.[0];
+  if (!account) throw new Error("No Solana accounts returned");
+  return parseSolanaAccount(account);
+};
+
+// src/lib/connectors/shared/utils.ts
+var isMobile = () => {
+  return typeof window !== "undefined" && /iPhone|iPad|iPod|Android/i.test(window.navigator.userAgent);
+};
+var isInWalletBrowser = (key) => {
+  return typeof window !== "undefined" && !!window.ethereum?.[key];
+};
+var openDeeplink = (url) => {
+  const link = document.createElement("a");
+  link.href = url;
+  link.click();
+};
+var waitForValue = (getValue) => {
+  return new Promise((resolve) => {
+    const check = () => {
+      const value = getValue();
+      if (value != null) resolve(value);
+      else window.setTimeout(check, 50);
+    };
+    check();
+  });
+};
+var signClient = null;
+var currentSession = null;
+var sessionChangeCallbacks = /* @__PURE__ */ new Set();
+var notifySessionChange = (session) => {
+  sessionChangeCallbacks.forEach((cb) => cb(session));
+};
+var onWalletConnectSessionChange = (callback) => {
+  sessionChangeCallbacks.add(callback);
+  callback(currentSession);
+  return () => sessionChangeCallbacks.delete(callback);
+};
+var initWalletConnect = async (config2) => {
+  if (signClient) return;
+  signClient = await SignClient.init({
+    projectId: config2.projectId,
+    metadata: config2.metadata
+  });
+  const pairings = signClient.core.pairing.pairings.values;
+  for (const pairing of pairings) {
+    if (!pairing.active) {
+      try {
+        await signClient.core.pairing.disconnect({ topic: pairing.topic });
+      } catch {
+      }
+    }
+  }
+  const sessions = signClient.session.values;
+  if (sessions.length > 0) {
+    const lastSession = sessions[sessions.length - 1];
+    currentSession = {
+      topic: lastSession.topic,
+      namespaces: lastSession.namespaces
+    };
+    notifySessionChange(currentSession);
+  }
+  signClient.on("session_delete", () => {
+    currentSession = null;
+    notifySessionChange(null);
+  });
+  signClient.on("session_update", ({ topic }) => {
+    const session = signClient.session.get(topic);
+    if (session) {
+      currentSession = {
+        topic: session.topic,
+        namespaces: session.namespaces
+      };
+      notifySessionChange(currentSession);
+    }
+  });
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible" && signClient) {
+        const sessions2 = signClient.session.values;
+        if (sessions2.length > 0 && !currentSession) {
+          const lastSession = sessions2[sessions2.length - 1];
+          currentSession = {
+            topic: lastSession.topic,
+            namespaces: lastSession.namespaces
+          };
+          notifySessionChange(currentSession);
+        }
+      }
+    });
+  }
+};
+var getCurrentSession = () => currentSession;
+var connectWalletConnect = async (options) => {
+  if (!signClient) {
+    throw new Error("WalletConnect not initialized. Call initWalletConnect first.");
+  }
+  const pairings = signClient.core.pairing.pairings.values;
+  for (const pairing of pairings) {
+    if (!pairing.active) {
+      try {
+        await signClient.core.pairing.disconnect({ topic: pairing.topic });
+      } catch {
+        console.log("Failed to disconnect pairing", pairing);
+      }
+    }
+  }
+  const namespace = options.chains[0]?.startsWith("solana") ? "solana" : "eip155";
+  const { uri, approval } = await signClient.connect({
+    optionalNamespaces: {
+      [namespace]: {
+        methods: options.methods,
+        chains: options.chains,
+        events: options.events
+      }
+    }
+  });
+  if (uri && options.onQRCode) {
+    options.onQRCode(uri);
+  }
+  const session = await approval();
+  currentSession = {
+    topic: session.topic,
+    namespaces: session.namespaces
+  };
+  return currentSession;
+};
+var disconnectWalletConnect = async () => {
+  if (!signClient || !currentSession) return;
+  await signClient.disconnect({
+    topic: currentSession.topic,
+    reason: { code: 6e3, message: "User disconnected" }
+  });
+  currentSession = null;
+};
+var requestWalletConnect = async (method, params, chainId) => {
+  if (!signClient || !currentSession) {
+    throw new Error("No active WalletConnect session");
+  }
+  try {
+    await signClient.ping({ topic: currentSession.topic });
+  } catch (e) {
+    console.error("WalletConnect session ping failed:", e);
+    currentSession = null;
+    notifySessionChange(null);
+    throw new Error("WalletConnect session expired. Please reconnect.");
+  }
+  console.log("WC request:", { method, params, chainId, topic: currentSession.topic });
+  try {
+    const result = await signClient.request({
+      topic: currentSession.topic,
+      chainId,
+      request: {
+        method,
+        params
+      }
+    });
+    console.log("WC response:", result);
+    return result;
+  } catch (e) {
+    console.error("WC request failed:", e);
+    throw e;
+  }
+};
+
+// src/lib/connectors/shared/walletconnect.ts
+var connectViaWalletConnect = async (wcConfig, parseSession, getDeeplink) => {
+  let qrUri = null;
+  const connectionPromise = connectWalletConnect({
+    chains: [...wcConfig.chains],
+    methods: [...wcConfig.methods],
+    events: [...wcConfig.events],
+    onQRCode: (uri2) => {
+      qrUri = uri2;
+    }
+  }).then((session) => parseSession(session.namespaces));
+  const uri = await waitForValue(() => qrUri);
+  if (isMobile() && getDeeplink) {
+    openDeeplink(getDeeplink(uri));
+  }
+  return qrcodeResult(uri, () => connectionPromise);
+};
+var createDeeplink = (baseUrl) => (uri) => `${baseUrl}?uri=${encodeURIComponent(uri)}`;
+var disconnectWc = async () => {
+  if (getCurrentSession()) {
+    await disconnectWalletConnect();
+  }
+};
+var disconnectWcOrSolana = async () => {
+  if (getCurrentSession()) {
+    await disconnectWalletConnect();
+  } else if (window.solana?.disconnect) {
+    await window.solana.disconnect();
+  }
+};
+var createWcEvmConnector = (config2) => {
+  const walletConfig = WALLETS.find((w) => w.id === config2.walletId);
+  const getDeeplink = createDeeplink(config2.wcDeeplink);
+  const isInWallet = () => isInWalletBrowser(config2.injectedKey);
+  return {
+    ...walletConfig,
+    type: "evm",
+    wallet: {
+      _connector: null,
+      connect: async () => {
+        if (isInWallet() && window.ethereum) {
+          return connectEvmInjected();
+        }
+        return connectViaWalletConnect(EVM_WC_CONFIG, getEvmAccountFromSession, getDeeplink);
+      },
+      disconnect: disconnectWc,
+      signMessage: async (message) => {
+        if (isInWallet() && window.ethereum) {
+          const accounts = await window.ethereum.request({ method: "eth_accounts" });
+          if (!accounts[0]) throw new Error("No account connected");
+          const result2 = await window.ethereum.request({
+            method: "personal_sign",
+            params: [message, accounts[0]]
+          });
+          return result2;
+        }
+        const session = getCurrentSession();
+        if (!session) {
+          throw new Error("No WalletConnect session");
+        }
+        const account = session.namespaces.eip155?.accounts?.[0];
+        if (!account) {
+          throw new Error("No EVM account in session");
+        }
+        const address = account.split(":")[2];
+        const result = await requestWalletConnect(
+          "personal_sign",
+          [message, address],
+          WC_CHAINS.EVM_MAINNET
+        );
+        return result;
+      }
+    }
+  };
+};
+var createWcSolanaConnector = (config2) => {
+  const walletConfig = WALLETS.find((w) => w.id === config2.walletId);
+  const getDeeplink = createDeeplink(config2.wcDeeplink);
+  const isInWallet = () => isInWalletBrowser(config2.injectedKey);
+  return {
+    ...walletConfig,
+    type: "solana",
+    wallet: {
+      _provider: null,
+      connect: async () => {
+        if (isInWallet() && window.solana) {
+          return connectSolanaInjected();
+        }
+        return connectViaWalletConnect(SOLANA_WC_CONFIG, getSolanaAccountFromSession, getDeeplink);
+      },
+      disconnect: disconnectWcOrSolana,
+      signMessage: async (message) => {
+        if (isInWallet()) {
+          return signSolanaInjected(message);
+        }
+        const session = getCurrentSession();
+        if (!session) {
+          throw new Error("No WalletConnect session");
+        }
+        const account = session.namespaces.solana?.accounts?.[0];
+        if (!account) {
+          throw new Error("No Solana account in session");
+        }
+        const pubkey = account.split(":")[2];
+        const messageBytes = new TextEncoder().encode(message);
+        const result = await requestWalletConnect(
+          "solana_signMessage",
+          { message: bs58.encode(messageBytes), pubkey },
+          WC_CHAINS.SOLANA_MAINNET
+        );
+        return result.signature;
+      }
+    }
+  };
+};
+
+// src/lib/connectors/phantom.ts
+var PHANTOM_CONNECT_URL = "https://phantom.app/ul/v1/connect";
+var PHANTOM_SIGN_MESSAGE_URL = "https://phantom.app/ul/v1/signMessage";
+var PHANTOM_BROWSE_URL = "https://phantom.app/ul/browse";
+var PHANTOM_CONFIG = {
+  connectUrl: PHANTOM_CONNECT_URL,
+  storageKeyPrefix: "phantom_mobile",
+  encryptionKeyParam: "phantom_encryption_public_key",
+  callbackParam: "phantom_callback"
+};
+var STORAGE_KEYS2 = {
+  PENDING: "phantom_mobile_pending",
+  SESSION: "phantom_mobile_session",
+  SIGN_PENDING: "phantom_mobile_sign_pending"
+};
+var isInPhantom = () => isInWalletBrowser("isPhantom");
+var phantomWalletConfig = WALLETS.find((i) => i.id === "phantom");
+var createPhantomEvmConnector = () => ({
+  ...phantomWalletConfig,
+  type: "evm",
+  wallet: {
+    _connector: null,
+    connect: async () => {
+      const currentUrl = encodeURIComponent(window.location.href);
+      window.location.href = `${PHANTOM_BROWSE_URL}/${currentUrl}?ref=${encodeURIComponent(
+        window.location.origin
+      )}`;
+      return pendingResult();
+    },
+    disconnect: async () => {
+    },
+    signMessage: async () => {
+      throw new Error("signMessage not supported via mobile deeplink");
+    }
+  }
+});
+var createPhantomSolanaConnector = () => ({
+  ...phantomWalletConfig,
+  type: "solana",
+  wallet: {
+    _provider: null,
+    connect: async () => {
+      if (isInPhantom() && window.solana) {
+        return connectSolanaInjected();
+      }
+      storage.setString(STORAGE_KEYS2.PENDING, "1");
+      const redirectUrl = `${window.location.origin}${window.location.pathname}?${PHANTOM_CONFIG.callbackParam}=1`;
+      window.location.href = buildConnectUrl(PHANTOM_CONFIG, {
+        appUrl: window.location.origin,
+        redirectUrl,
+        cluster: "mainnet-beta",
+        chain: "solana"
+      });
+      return pendingResult();
+    },
+    disconnect: async () => {
+      storage.remove(STORAGE_KEYS2.SESSION);
+    },
+    signMessage: async (message) => {
+      if (isInPhantom()) {
+        return signSolanaInjected(message);
+      }
+      const redirectUrl = `${window.location.origin}${window.location.pathname}?phantom_sign_callback=1`;
+      const signUrl = buildSignMessageUrl(
+        PHANTOM_SIGN_MESSAGE_URL,
+        PHANTOM_CONFIG,
+        STORAGE_KEYS2.SESSION,
+        message,
+        redirectUrl
+      );
+      if (!signUrl) {
+        throw new Error("No Phantom session for signing");
+      }
+      storage.setString(STORAGE_KEYS2.SIGN_PENDING, "1");
+      window.location.href = signUrl;
+      return new Promise(() => {
+      });
+    }
+  }
+});
+var isPhantomMobilePending = () => storage.getString(STORAGE_KEYS2.PENDING) === "1";
+var handlePhantomMobileCallback = () => handleMobileCallback(PHANTOM_CONFIG, STORAGE_KEYS2.PENDING, STORAGE_KEYS2.SESSION);
+var restorePhantomMobileSession = () => restoreMobileSession(STORAGE_KEYS2.SESSION);
+var isPhantomSignPending = () => storage.getString(STORAGE_KEYS2.SIGN_PENDING) === "1";
+var handlePhantomSignCallback = () => {
+  const params = new URLSearchParams(window.location.search);
+  if (!params.has("phantom_sign_callback")) return null;
+  if (!isPhantomSignPending()) return null;
+  const signature = parseSignMessageResponse(PHANTOM_CONFIG, STORAGE_KEYS2.SESSION);
+  storage.remove(STORAGE_KEYS2.SIGN_PENDING);
+  window.history.replaceState({}, "", window.location.pathname);
+  return signature;
+};
+
+// src/lib/connectors/metamask.ts
+var METAMASK_CONFIG = {
+  walletId: "metamask",
+  wcDeeplink: "https://metamask.app.link/wc",
+  injectedKey: "isMetaMask"
+};
+var createMetaMaskEvmConnector = () => createWcEvmConnector(METAMASK_CONFIG);
+
+// src/lib/connectors/solflare.ts
+var SOLFLARE_CONNECT_URL = "https://solflare.com/ul/v1/connect";
+var SOLFLARE_SIGN_MESSAGE_URL = "https://solflare.com/ul/v1/signMessage";
+var SOLFLARE_CONFIG = {
+  connectUrl: SOLFLARE_CONNECT_URL,
+  storageKeyPrefix: "solflare_mobile",
+  encryptionKeyParam: "solflare_encryption_public_key",
+  callbackParam: "solflare_callback"
+};
+var STORAGE_KEYS3 = {
+  PENDING: "solflare_mobile_pending",
+  SESSION: "solflare_mobile_session",
+  SIGN_PENDING: "solflare_mobile_sign_pending"
+};
+var solflareWalletConfig = WALLETS.find((i) => i.id === "solflare");
+var createSolflareSolanaMobileConnector = () => ({
+  ...solflareWalletConfig,
+  type: "solana",
+  wallet: {
+    _provider: null,
+    connect: async () => {
+      storage.setString(STORAGE_KEYS3.PENDING, "1");
+      const redirectUrl = `${window.location.origin}${window.location.pathname}?${SOLFLARE_CONFIG.callbackParam}=1`;
+      window.location.href = buildConnectUrl(SOLFLARE_CONFIG, {
+        appUrl: window.location.origin,
+        redirectUrl,
+        cluster: "mainnet-beta"
+      });
+      return pendingResult();
+    },
+    disconnect: async () => {
+      storage.remove(STORAGE_KEYS3.SESSION);
+    },
+    signMessage: async (message) => {
+      const redirectUrl = `${window.location.origin}${window.location.pathname}?solflare_sign_callback=1`;
+      const signUrl = buildSignMessageUrl(
+        SOLFLARE_SIGN_MESSAGE_URL,
+        SOLFLARE_CONFIG,
+        STORAGE_KEYS3.SESSION,
+        message,
+        redirectUrl
+      );
+      if (!signUrl) {
+        throw new Error("No Solflare session for signing");
+      }
+      storage.setString(STORAGE_KEYS3.SIGN_PENDING, "1");
+      window.location.href = signUrl;
+      return new Promise(() => {
+      });
+    }
+  }
+});
+var isSolflareMobilePending = () => storage.getString(STORAGE_KEYS3.PENDING) === "1";
+var handleSolflareMobileCallback = () => handleMobileCallback(SOLFLARE_CONFIG, STORAGE_KEYS3.PENDING, STORAGE_KEYS3.SESSION);
+var restoreSolflareMobileSession = () => restoreMobileSession(STORAGE_KEYS3.SESSION);
+var isSolflareSignPending = () => storage.getString(STORAGE_KEYS3.SIGN_PENDING) === "1";
+var handleSolflareSignCallback = () => {
+  const params = new URLSearchParams(window.location.search);
+  if (!params.has("solflare_sign_callback")) return null;
+  if (!isSolflareSignPending()) return null;
+  const signature = parseSignMessageResponse(SOLFLARE_CONFIG, STORAGE_KEYS3.SESSION);
+  storage.remove(STORAGE_KEYS3.SIGN_PENDING);
+  window.history.replaceState({}, "", window.location.pathname);
+  return signature;
+};
+
+// src/lib/connectors/trust.ts
+var TRUST_CONFIG = {
+  walletId: "trust",
+  wcDeeplink: "https://link.trustwallet.com/wc",
+  injectedKey: "isTrust"
+};
+var createTrustEvmMobileConnector = () => createWcEvmConnector(TRUST_CONFIG);
+var createTrustSolanaMobileConnector = () => createWcSolanaConnector(TRUST_CONFIG);
+
+// src/lib/connectors/rainbow.ts
+var RAINBOW_CONFIG = {
+  walletId: "rainbow",
+  wcDeeplink: "https://rnbwapp.com/wc",
+  injectedKey: "isRainbow"
+};
+var createRainbowEvmMobileConnector = () => createWcEvmConnector(RAINBOW_CONFIG);
+
+// src/lib/connectors/exodus.ts
+var EXODUS_CONFIG = {
+  walletId: "exodus",
+  wcDeeplink: "https://exodus.com/wc",
+  injectedKey: "isExodus"
+};
+var createExodusEvmMobileConnector = () => createWcEvmConnector(EXODUS_CONFIG);
+var createExodusSolanaMobileConnector = () => createWcSolanaConnector(EXODUS_CONFIG);
+
+// src/lib/connectors/binance.ts
+var BINANCE_CONFIG = {
+  walletId: "binance",
+  wcDeeplink: "bnc://app.binance.com/cedefi/wc",
+  injectedKey: "isBinance"
+};
+var createBinanceEvmConnector = () => createWcEvmConnector(BINANCE_CONFIG);
+var createBinanceSolanaConnector = () => createWcSolanaConnector(BINANCE_CONFIG);
+
+// src/lib/evm/connectors.ts
+var EVM_FALLBACK_CONNECTORS = [
+  { id: "phantom", create: createPhantomEvmConnector },
+  { id: "metamask", create: createMetaMaskEvmConnector },
+  { id: "trust", create: createTrustEvmMobileConnector },
+  { id: "binance", create: createBinanceEvmConnector },
+  { id: "rainbow", create: createRainbowEvmMobileConnector },
+  { id: "exodus", create: createExodusEvmMobileConnector }
+];
+var getEvmConnectors = () => {
+  const wagmiConnectors = getConnectors(getEvmConfig());
+  const connectors = wagmiConnectors.map((c) => ({
+    id: normalizeEvmWalletId(c.id),
+    name: c.name,
+    icon: c.icon,
+    type: "evm",
+    installed: true,
+    wallet: {
+      _connector: c,
+      connect: async () => {
+        const result = await connect(getEvmConfig(), { connector: c });
+        if (!result.accounts[0]) throw new Error("No accounts returned");
+        return connectedResult(result.accounts[0], { chainId: result.chainId });
+      },
+      disconnect: async () => {
+        await disconnect(getEvmConfig());
+      },
+      signMessage: async (message) => {
+        return signMessage(getEvmConfig(), { message });
+      }
+    }
+  }));
+  addFallbackConnectors(connectors, EVM_FALLBACK_CONNECTORS);
+  return connectors;
+};
+var watchEvmConnections = (onChange) => {
+  return watchConnections(getEvmConfig(), { onChange });
+};
+
+// src/lib/solana/connection.ts
+var currentConnection = {
+  connection: null,
+  connector: null
+};
+var connectionListeners = /* @__PURE__ */ new Set();
+var notifyConnectionListeners = () => {
+  connectionListeners.forEach((listener) => listener(currentConnection));
+};
+var setConnection = (connection, connector) => {
+  currentConnection = { connection, connector };
+  notifyConnectionListeners();
+};
+var watchSolanaConnection = (onChange) => {
+  connectionListeners.add(onChange);
+  onChange(currentConnection);
+  return () => {
+    connectionListeners.delete(onChange);
+  };
+};
+var createSolanaConnector = (provider) => {
+  const id = normalizeSolanaWalletId(provider.name.toLowerCase().replace(/\s+/g, "-"));
+  const connector = {
+    id,
+    name: provider.name,
+    icon: provider.icon,
+    type: "solana",
+    installed: true,
+    wallet: {
+      _provider: provider,
+      connect: async () => {
+        const feature = provider.features["standard:connect"];
+        const result = await feature.connect();
+        const account = result.accounts[0];
+        if (!account) throw new Error("No account returned from wallet");
+        const connectResult = connectedResult(account.address, {
+          publicKey: new Uint8Array(account.publicKey)
+        });
+        storage.setString(STORAGE_KEYS.SOLANA_WALLET, id);
+        setConnection(connectResult, connector);
+        return connectResult;
+      },
+      disconnect: async () => {
+        const features = provider.features;
+        const disconnectFeature = features["standard:disconnect"];
+        if (disconnectFeature?.disconnect) {
+          await disconnectFeature.disconnect();
+        }
+        storage.remove(STORAGE_KEYS.SOLANA_WALLET);
+        setConnection(null, null);
+      },
+      signMessage: async (message) => {
+        const features = provider.features;
+        const signFeature = features["solana:signMessage"];
+        if (!signFeature?.signMessage) {
+          throw new Error("signMessage not supported by wallet");
+        }
+        const account = provider.accounts[0];
+        if (!account) throw new Error("No account connected");
+        const encodedMessage = new TextEncoder().encode(message);
+        const result = await signFeature.signMessage({ message: encodedMessage, account });
+        const signature = result[0]?.signature;
+        if (!signature) throw new Error("No signature returned");
+        return bs58.encode(signature);
+      }
+    }
+  };
+  return connector;
+};
+var createSolanaMobileConnector = (connector) => ({
+  ...connector,
+  wallet: {
+    ...connector.wallet,
+    disconnect: async () => {
+      storage.remove(STORAGE_KEYS.SOLANA_WALLET);
+      setConnection(null, null);
+      await connector.wallet.disconnect();
+    }
+  }
+});
+var SOLANA_FALLBACK_CONNECTORS = [
+  { id: "phantom", create: () => createSolanaMobileConnector(createPhantomSolanaConnector()) },
+  // { id: 'metamask', create: () => createSolanaMobileConnector(createMetaMaskSolanaConnector()) },
+  {
+    id: "solflare",
+    create: () => createSolanaMobileConnector(createSolflareSolanaMobileConnector())
+  },
+  { id: "trust", create: () => createSolanaMobileConnector(createTrustSolanaMobileConnector()) },
+  { id: "binance", create: () => createSolanaMobileConnector(createBinanceSolanaConnector()) },
+  { id: "exodus", create: () => createSolanaMobileConnector(createExodusSolanaMobileConnector()) }
+];
+var getSolanaWallets = () => {
+  const { get } = getWallets();
+  const wallets = get();
+  const connectors = wallets.filter(isWalletAdapterCompatibleStandardWallet).map(createSolanaConnector);
+  addFallbackConnectors(connectors, SOLANA_FALLBACK_CONNECTORS);
+  return connectors;
+};
+var onSolanaWalletsChange = (callback) => {
+  const { on } = getWallets();
+  const handleChange = () => {
+    callback(getSolanaWallets());
+  };
+  const unsubscribeRegister = on("register", handleChange);
+  const unsubscribeUnregister = on("unregister", handleChange);
+  return () => {
+    unsubscribeRegister();
+    unsubscribeUnregister();
+  };
+};
+var MOBILE_STRATEGIES = [
+  {
+    id: "phantom",
+    isPending: isPhantomMobilePending,
+    handleCallback: handlePhantomMobileCallback,
+    restoreSession: restorePhantomMobileSession,
+    createConnector: () => createSolanaMobileConnector(createPhantomSolanaConnector())
+  },
+  {
+    id: "solflare",
+    isPending: isSolflareMobilePending,
+    handleCallback: handleSolflareMobileCallback,
+    restoreSession: restoreSolflareMobileSession,
+    createConnector: () => createSolanaMobileConnector(createSolflareSolanaMobileConnector())
+  }
+];
+var tryMobileCallback = () => {
+  for (const strategy of MOBILE_STRATEGIES) {
+    if (strategy.isPending()) {
+      const result = strategy.handleCallback();
+      if (result) {
+        setConnection(result, strategy.createConnector());
+        storage.setString(STORAGE_KEYS.SOLANA_WALLET, strategy.id);
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var tryRestoreSession = () => {
+  for (const strategy of MOBILE_STRATEGIES) {
+    const result = strategy.restoreSession();
+    if (result) {
+      setConnection(result, strategy.createConnector());
+      return true;
+    }
+  }
+  return false;
+};
+var tryReconnectSavedWallet = (savedWalletId) => {
+  const wallets = getSolanaWallets();
+  const savedConnector = wallets.find((c) => c.id === savedWalletId);
+  if (savedConnector) {
+    savedConnector.wallet.connect().then((result) => {
+      if (result.status === "connected") {
+        setConnection(result, savedConnector);
+      }
+    }).catch(() => {
+      storage.remove(STORAGE_KEYS.SOLANA_WALLET);
+    });
+    return true;
+  }
+  return false;
+};
+var reconnectSolana = () => {
+  if (tryMobileCallback()) return;
+  if (tryRestoreSession()) return;
+  const savedWalletId = storage.getString(STORAGE_KEYS.SOLANA_WALLET);
+  if (!savedWalletId) return;
+  if (tryReconnectSavedWallet(savedWalletId)) return;
+  const { on } = getWallets();
+  const unsubscribe = on("register", () => {
+    if (tryReconnectSavedWallet(savedWalletId)) unsubscribe();
+  });
+  window.setTimeout(unsubscribe, 5e3);
+};
+var checkPhantomSignCallback = () => {
+  if (!isPhantomSignPending()) return null;
+  return handlePhantomSignCallback();
+};
+var checkSolflareSignCallback = () => {
+  if (!isSolflareSignPending()) return null;
+  return handleSolflareSignCallback();
+};
+var useEvmWallet = (options) => {
+  const [evmConnectors, setEvmConnectors] = createSignal([]);
+  const [evmConnection, setEvmConnection] = createSignal(null);
+  const [connectedConnector, setConnectedConnector] = createSignal(null);
+  onMount(() => {
+    createEvmConfig(options.chains);
+    setEvmConnectors(getEvmConnectors());
+    const unsubscribe = watchEvmConnections((connections) => {
+      const connection = connections[0];
+      if (connection && connection.accounts[0]) {
+        setEvmConnection(connectedResult(connection.accounts[0], { chainId: connection.chainId }));
+      } else {
+        setEvmConnection(null);
+      }
+    });
+    onCleanup(unsubscribe);
+  });
+  const connectEvm = async (connector) => {
+    const result = await connector.wallet.connect();
+    setConnectedConnector(connector);
+    if (result.status === "connected") {
+      setEvmConnection(result);
+    } else if (result.status === "qrcode") {
+      result.wait().then((connectedResult2) => setEvmConnection(connectedResult2)).catch(() => {
+      });
+    }
+    return result;
+  };
+  const disconnectEvm = async () => {
+    const connector = connectedConnector();
+    if (connector) {
+      await connector.wallet.disconnect();
+      setConnectedConnector(null);
+    }
+    setEvmConnection(null);
+  };
+  return {
+    evmConnectors,
+    evmConnection,
+    setEvmConnection,
+    connectEvm,
+    disconnectEvm,
+    connectedEvmConnector: connectedConnector
+  };
+};
+var useSolanaWallet = () => {
+  const [solanaConnectors, setSolanaConnectors] = createSignal([]);
+  const [solanaConnection, setSolanaConnection] = createSignal(null);
+  const [connectedConnector, setConnectedConnector] = createSignal(
+    null
+  );
+  onMount(() => {
+    setSolanaConnectors(getSolanaWallets());
+    const unsubscribeWallets = onSolanaWalletsChange(setSolanaConnectors);
+    const unsubscribeConnection = watchSolanaConnection((state) => {
+      setSolanaConnection(state.connection);
+      if (state.connector) {
+        setConnectedConnector(state.connector);
+      }
+    });
+    reconnectSolana();
+    onCleanup(() => {
+      unsubscribeWallets();
+      unsubscribeConnection();
+    });
+  });
+  const connectSolana = async (connector) => {
+    setConnectedConnector(connector);
+    const result = await connector.wallet.connect();
+    if (result.status === "connected") {
+      setSolanaConnection(result);
+    } else if (result.status === "qrcode") {
+      result.wait().then((connectedResult2) => setSolanaConnection(connectedResult2)).catch(() => {
+      });
+    }
+    return result;
+  };
+  const disconnectSolana = async () => {
+    const connector = connectedConnector();
+    if (connector) {
+      await connector.wallet.disconnect();
+      setConnectedConnector(null);
+      setSolanaConnection(null);
+      return;
+    }
+    const wallets = getSolanaWallets();
+    for (const wallet of wallets) {
+      if (wallet.wallet._provider?.accounts?.length > 0) {
+        await wallet.wallet.disconnect();
+        setSolanaConnection(null);
+        return;
+      }
+    }
+  };
+  return {
+    solanaConnectors,
+    solanaConnection,
+    setSolanaConnection,
+    connectSolana,
+    disconnectSolana,
+    connectedSolanaConnector: connectedConnector
+  };
+};
+var useWalletConnect = (options) => {
+  onMount(async () => {
+    if (!options.config) return;
+    await initWalletConnect(options.config);
+    const handleSession = (session) => {
+      if (!session) return;
+      if (session.namespaces.eip155?.accounts?.[0] && options.onEvmConnection) {
+        options.onEvmConnection(getEvmAccountFromSession(session.namespaces));
+      }
+      if (session.namespaces.solana?.accounts?.[0] && options.onSolanaConnection) {
+        getSolanaAccountFromSession(session.namespaces).then(options.onSolanaConnection).catch((err) => console.error("Solana session parse error:", err));
+      }
+    };
+    const existingSession = getCurrentSession();
+    if (existingSession) {
+      handleSession(existingSession);
+    }
+    const unsubscribe = onWalletConnectSessionChange(handleSession);
+    onCleanup(unsubscribe);
+  });
+  const hasWcEvmSession = () => {
+    return !!getCurrentSession()?.namespaces.eip155;
+  };
+  const hasWcSolanaSession = () => {
+    return !!getCurrentSession()?.namespaces.solana;
+  };
+  const disconnectWcEvm = async () => {
+    if (hasWcEvmSession()) {
+      await disconnectWalletConnect();
+    }
+  };
+  const disconnectWcSolana = async () => {
+    if (hasWcSolanaSession()) {
+      await disconnectWalletConnect();
+    }
+  };
+  const signWcEvmMessage = async (message) => {
+    const session = getCurrentSession();
+    if (!session) throw new Error("No WalletConnect session");
+    const account = session.namespaces.eip155?.accounts?.[0];
+    if (!account) throw new Error("No EVM account in session");
+    const address = account.split(":")[2];
+    return requestWalletConnect("personal_sign", [message, address], WC_CHAINS.EVM_MAINNET);
+  };
+  const signWcSolanaMessage = async (message) => {
+    const session = getCurrentSession();
+    if (!session) throw new Error("No WalletConnect session");
+    const account = session.namespaces.solana?.accounts?.[0];
+    if (!account) throw new Error("No Solana account in session");
+    const pubkey = account.split(":")[2];
+    const messageBytes = new TextEncoder().encode(message);
+    const result = await requestWalletConnect(
+      "solana_signMessage",
+      { message: bs58.encode(messageBytes), pubkey },
+      WC_CHAINS.SOLANA_MAINNET
+    );
+    return result.signature;
+  };
+  return {
+    disconnectWcEvm,
+    disconnectWcSolana,
+    hasWcEvmSession,
+    hasWcSolanaSession,
+    signWcEvmMessage,
+    signWcSolanaMessage
+  };
+};
+
+// src/lib/context/WalletContext.tsx
+var WalletContext = createContext();
+var WalletProvider = (props) => {
+  const evm = useEvmWallet({
+    chains: props.evmChains
+  });
+  const solana = useSolanaWallet();
+  const wc = useWalletConnect({
+    config: props.walletConnect,
+    onEvmConnection: evm.setEvmConnection,
+    onSolanaConnection: solana.setSolanaConnection
+  });
+  const disconnectEvm = async () => {
+    if (evm.connectedEvmConnector()) {
+      await evm.disconnectEvm();
+    } else {
+      await wc.disconnectWcEvm();
+      evm.setEvmConnection(null);
+    }
+  };
+  const disconnectSolana = async () => {
+    if (solana.connectedSolanaConnector()) {
+      await solana.disconnectSolana();
+    } else if (wc.hasWcSolanaSession()) {
+      await wc.disconnectWcSolana();
+      solana.setSolanaConnection(null);
+    } else {
+      await solana.disconnectSolana();
+    }
+  };
+  const groupedWallets = () => {
+    const evmMap = new Map(evm.evmConnectors().map((c) => [c.id, c]));
+    const solanaMap = new Map(solana.solanaConnectors().map((c) => [c.id, c]));
+    return WALLETS.map((config2) => {
+      const evm2 = evmMap.get(config2.id);
+      const solana2 = solanaMap.get(config2.id);
+      return {
+        id: config2.id,
+        name: config2.name,
+        evm: evm2,
+        solana: solana2
+      };
+    });
+  };
+  const signMessage = async (chainType, message) => {
+    if (chainType === "evm") {
+      const connector = evm.connectedEvmConnector();
+      if (connector) {
+        return connector.wallet.signMessage(message);
+      }
+      if (wc.hasWcEvmSession()) {
+        return wc.signWcEvmMessage(message);
+      }
+      throw new Error("EVM wallet not connected");
+    } else {
+      const connector = solana.connectedSolanaConnector();
+      if (connector) {
+        return connector.wallet.signMessage(message);
+      }
+      if (wc.hasWcSolanaSession()) {
+        return wc.signWcSolanaMessage(message);
+      }
+      throw new Error("Solana wallet not connected");
+    }
+  };
+  const value = {
+    evmConnectors: evm.evmConnectors,
+    evmConnection: evm.evmConnection,
+    solanaConnectors: solana.solanaConnectors,
+    solanaConnection: solana.solanaConnection,
+    groupedWallets,
+    connectEvm: evm.connectEvm,
+    disconnectEvm,
+    connectSolana: solana.connectSolana,
+    disconnectSolana,
+    signMessage
+  };
+  return createComponent(WalletContext.Provider, {
+    value,
+    get children() {
+      return props.children;
+    }
+  });
+};
+function useWallet() {
+  const context = useContext(WalletContext);
+  if (!context) {
+    throw new Error("useWallet must be used within a WalletProvider");
+  }
+  return context;
+}
+
+export { WALLETS, WalletProvider, checkPhantomSignCallback, checkSolflareSignCallback, createEvmConfig, getEvmConfig, getEvmConnectors, getSolanaWallets, initWalletConnect, onSolanaWalletsChange, reconnectSolana, useWallet, watchEvmConnections, watchSolanaConnection };