@0xtrails/svm 1.0.0

package/dist/index.js

@@ -0,0 +1,962 @@
+"use client";
+import { useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { EDGE_RAIL, EdgePluginContext, createSolanaEdgeDestinationConfig, createSolanaEdgeOriginConfig } from "0xtrails/plugins/edge";
+import { SOLANA_EDGE_CHAIN_ID, SOLANA_MAINNET_CHAIN_ID, getEdgeSolanaRpcUrls, getSolanaTokens, isSolanaAddress, isSolanaChainId, resolveSolanaMainnetJsonRpcUrls, setSolanaSupportEnabled, useTrails } from "0xtrails";
+import { UnifiedWalletProvider } from "0xtrails/widget";
+import { AccountRole, address, appendTransactionMessageInstructions, compileTransaction, createTransactionMessage, getBase64Decoder, getBase64Encoder, getTransactionDecoder, getTransactionEncoder, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
+import bs58 from "bs58";
+import { hexToBytes } from "viem";
+import { getWallets } from "@wallet-standard/app";
+import { jsx } from "react/jsx-runtime";
+//#region src/edge/executeRelaySolanaQuote.ts
+var ErrEVMStepInSolanaQuote = class extends Error {
+	constructor() {
+		super("EVM transaction step in Solana provider quote");
+		this.name = "ErrEVMStepInSolanaQuote";
+	}
+};
+function normalizeRelayStatus(status) {
+	return (status ?? "").trim().toLowerCase();
+}
+function providerQuoteToJson(providerQuote) {
+	if (providerQuote == null) throw new Error("provider quote is nil");
+	if (typeof providerQuote === "string") return providerQuote;
+	return JSON.stringify(providerQuote);
+}
+function instructionsEmptyOrNull(raw) {
+	if (raw == null) return true;
+	if (typeof raw === "string") {
+		const s = raw.trim();
+		if (s === "" || s === "null") return true;
+	}
+	if (Array.isArray(raw)) return raw.length === 0;
+	return false;
+}
+function relayInstructionDataLooksHex(s) {
+	if (s.length % 2 !== 0) return false;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (!(c >= 48 && c <= 57 || c >= 97 && c <= 102 || c >= 65 && c <= 70)) return false;
+	}
+	return true;
+}
+function base64ToBytes(s) {
+	return new Uint8Array(getBase64Encoder().encode(s));
+}
+function decodeRelayInstructionDataSync(s) {
+	const t = s.trim();
+	if (t === "") return /* @__PURE__ */ new Uint8Array(0);
+	let h = t;
+	if (h.startsWith("0x") || h.startsWith("0X")) h = h.slice(2);
+	if (h.length % 2 === 0 && relayInstructionDataLooksHex(h)) return hexToBytes(`0x${h}`);
+	try {
+		return bs58.decode(t);
+	} catch {}
+	return base64ToBytes(t);
+}
+function parseSolanaStepData(data) {
+	if (data == null || typeof data !== "object") return { kind: "skip" };
+	const m = data;
+	const toStr = typeof m.to === "string" ? m.to.trim() : "";
+	const hasChainId = "chainId" in m;
+	const evmLike = toStr.startsWith("0x") && hasChainId;
+	const rawInst = m.instructions;
+	const hasInstKey = "instructions" in m;
+	if (evmLike && (!hasInstKey || instructionsEmptyOrNull(rawInst))) throw new ErrEVMStepInSolanaQuote();
+	const txB64 = typeof m.transaction === "string" ? m.transaction.trim() : "";
+	if (txB64 !== "") return {
+		kind: "wire",
+		b64: txB64
+	};
+	if (!hasInstKey || instructionsEmptyOrNull(rawInst)) return { kind: "skip" };
+	const instList = rawInst;
+	if (!Array.isArray(instList) || instList.length === 0) return { kind: "skip" };
+	const feePayerStr = typeof m.feePayer === "string" ? m.feePayer.trim() : "";
+	let feePayer = null;
+	if (feePayerStr) try {
+		feePayer = address(feePayerStr);
+	} catch {
+		feePayer = null;
+	}
+	return {
+		kind: "instructions",
+		feePayer,
+		list: instList
+	};
+}
+function svmInstructionToInstruction(inst) {
+	const programAddress = address(inst.programId.trim());
+	const data = inst.data?.trim() ? decodeRelayInstructionDataSync(inst.data) : /* @__PURE__ */ new Uint8Array(0);
+	return {
+		accounts: inst.keys.map((k, j) => {
+			const pks = (k.pubkey ?? k.publicKey ?? "").trim();
+			if (!pks) throw new Error(`instruction account ${j}: missing pubkey`);
+			return {
+				address: address(pks),
+				role: k.isSigner ? k.isWritable || k.writable ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER : k.isWritable || k.writable ? AccountRole.WRITABLE : AccountRole.READONLY
+			};
+		}),
+		data,
+		programAddress
+	};
+}
+async function callSolanaRpc({ rpcUrl, method, params, parseResult }) {
+	const response = await fetch(rpcUrl, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			jsonrpc: "2.0",
+			id: Date.now(),
+			method,
+			params
+		})
+	});
+	if (!response.ok) throw new Error(`Solana RPC ${method} failed: HTTP ${response.status}`);
+	const payload = await response.json();
+	if (payload.error) throw new Error(payload.error.message || "Solana RPC returned an error");
+	const parsedResult = parseResult(payload.result);
+	if (parsedResult === void 0) throw new Error(`Invalid Solana RPC ${method} response`);
+	return parsedResult;
+}
+async function getLatestBlockhash(rpcUrl) {
+	return callSolanaRpc({
+		rpcUrl,
+		method: "getLatestBlockhash",
+		params: [{ commitment: "finalized" }],
+		parseResult: (result) => {
+			const value = result?.value;
+			return typeof value?.blockhash === "string" && typeof value.lastValidBlockHeight === "number" ? {
+				blockhash: value.blockhash,
+				lastValidBlockHeight: value.lastValidBlockHeight
+			} : void 0;
+		}
+	});
+}
+async function sendRawTransaction(rpcUrl, serializedTransaction, options) {
+	const config = {
+		...typeof options === "object" && options !== null ? options : {},
+		encoding: "base64"
+	};
+	return callSolanaRpc({
+		rpcUrl,
+		method: "sendTransaction",
+		params: [getBase64Decoder().decode(serializedTransaction), config],
+		parseResult: (result) => typeof result === "string" ? result : void 0
+	});
+}
+async function signTransactionBytes(tx, signSerializedTransaction) {
+	return signSerializedTransaction(new Uint8Array(getTransactionEncoder().encode(tx)));
+}
+async function callSolanaRpcWithFallback$1(rpcUrls, method, call) {
+	const errors = [];
+	for (const rpcUrl of rpcUrls) try {
+		return await call(rpcUrl);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "unknown Solana RPC error";
+		errors.push(`${rpcUrl}: ${message}`);
+		console.warn("[trails-sdk] Solana RPC failed; trying fallback", {
+			rpcUrl,
+			method,
+			error: message
+		});
+	}
+	throw new Error(`Solana RPC ${method} failed on all configured endpoints: ${errors.join(" | ")}`);
+}
+async function getLatestBlockhashWithFallback(walletConnection, rpcUrls) {
+	if (walletConnection?.getLatestBlockhash) try {
+		return await walletConnection.getLatestBlockhash("finalized");
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "unknown Solana RPC error";
+		console.warn("[trails-sdk] Solana wallet RPC failed; trying fallback", {
+			method: "getLatestBlockhash",
+			error: message
+		});
+	}
+	return callSolanaRpcWithFallback$1(rpcUrls, "getLatestBlockhash", (rpcUrl) => getLatestBlockhash(rpcUrl));
+}
+async function sendRawTransactionWithFallback(walletConnection, rpcUrls, serializedTransaction, options) {
+	if (walletConnection) try {
+		return await walletConnection.sendRawTransaction(serializedTransaction, options);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "unknown Solana RPC error";
+		console.warn("[trails-sdk] Solana wallet RPC failed; trying fallback", {
+			method: "sendRawTransaction",
+			error: message
+		});
+	}
+	return callSolanaRpcWithFallback$1(rpcUrls, "sendRawTransaction", (rpcUrl) => sendRawTransaction(rpcUrl, serializedTransaction, options));
+}
+async function fetchSignatureStatus(rpcUrls, sig) {
+	return callSolanaRpcWithFallback$1(rpcUrls, "getSignatureStatuses", (rpcUrl) => callSolanaRpc({
+		rpcUrl,
+		method: "getSignatureStatuses",
+		params: [[sig]],
+		parseResult: (result) => {
+			return (result?.value)?.[0] ?? null;
+		}
+	}));
+}
+/** Poll getSignatureStatuses (HTTP) instead of WebSocket confirmTransaction to avoid 403/timeout. */
+async function pollConfirmation(rpcUrls, sig, timeoutMs = 12e4) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const status = await fetchSignatureStatus(rpcUrls, sig);
+		if (status?.err) throw new Error(`Solana transaction failed: ${JSON.stringify(status.err)}`);
+		const cs = status?.confirmationStatus;
+		if (cs === "confirmed" || cs === "finalized") return;
+		await new Promise((r) => setTimeout(r, 2e3));
+	}
+	throw new Error(`Transaction not confirmed within ${timeoutMs / 1e3}s. Check signature ${sig} on Solana Explorer.`);
+}
+/**
+* Signs and submits Solana txs from Relay edge.providerQuote.
+* Uses Wallet Standard-style serialized transaction signing so the SVM package does not need web3.js transaction classes.
+* Returns the submitted transaction signatures.
+*/
+async function executeRelaySolanaQuote(params) {
+	const raw = providerQuoteToJson(params.providerQuote);
+	if (!raw.trim()) throw new Error("empty provider quote");
+	const steps = JSON.parse(raw).steps ?? [];
+	const rpcUrls = resolveSolanaMainnetJsonRpcUrls(params.rpcUrls);
+	const wc = params.walletConnection;
+	const signerPk = address(params.signerPublicKeyBase58.trim());
+	const signatures = [];
+	for (const step of steps) {
+		const items = step.items ?? [];
+		for (const item of items) {
+			const st = normalizeRelayStatus(item.status);
+			if (st !== "" && st !== "incomplete") continue;
+			if (item.data == null || item.data === "null") continue;
+			const action = parseSolanaStepData(item.data);
+			if (action.kind === "skip") continue;
+			if (action.kind === "wire") {
+				const sig = await sendRawTransactionWithFallback(wc, rpcUrls, await signTransactionBytes(getTransactionDecoder().decode(base64ToBytes(action.b64)), params.signSerializedTransaction), {
+					skipPreflight: false,
+					maxRetries: 5
+				});
+				console.log("[trails-sdk] Solana edge wire tx sent:", sig);
+				signatures.push(sig);
+				await pollConfirmation(rpcUrls, sig);
+				continue;
+			}
+			const bh = await getLatestBlockhashWithFallback(wc, rpcUrls);
+			const ixs = action.list.map((i) => svmInstructionToInstruction(i));
+			const payer = action.feePayer ?? signerPk;
+			const sig = await sendRawTransactionWithFallback(wc, rpcUrls, await signTransactionBytes(compileTransaction(appendTransactionMessageInstructions(ixs, setTransactionMessageLifetimeUsingBlockhash({
+				blockhash: bh.blockhash,
+				lastValidBlockHeight: BigInt(bh.lastValidBlockHeight)
+			}, setTransactionMessageFeePayer(payer, createTransactionMessage({ version: "legacy" }))))), params.signSerializedTransaction), {
+				skipPreflight: false,
+				maxRetries: 5
+			});
+			console.log("[trails-sdk] Solana edge ix tx sent:", sig);
+			signatures.push(sig);
+			await pollConfirmation(rpcUrls, sig);
+		}
+	}
+	return signatures;
+}
+//#endregion
+//#region src/walletDetection/rpcConnection.ts
+function uniqueNonEmpty(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const value of values) {
+		const trimmed = value?.trim();
+		if (!trimmed || seen.has(trimmed)) continue;
+		seen.add(trimmed);
+		out.push(trimmed);
+	}
+	return out;
+}
+function resolveSolanaRpcUrls(options = {}) {
+	return resolveSolanaMainnetJsonRpcUrls(options.rpcUrls);
+}
+function toBase64(data) {
+	if (data instanceof Uint8Array) {
+		if (typeof btoa === "function") {
+			let binary = "";
+			for (const byte of data) binary += String.fromCharCode(byte);
+			return btoa(binary);
+		}
+		const bytes = Array.from(data, (byte) => String.fromCharCode(byte)).join("");
+		return globalThis.btoa(bytes);
+	}
+	if (data instanceof ArrayBuffer) return toBase64(new Uint8Array(data));
+	if (ArrayBuffer.isView(data)) return toBase64(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+	throw new Error("Unsupported serialized transaction format");
+}
+async function callSolanaRpcWithFallback({ rpcUrls, method, params, parseResult }) {
+	const errors = [];
+	for (const rpcUrl of rpcUrls) try {
+		const response = await fetch(rpcUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: Date.now(),
+				method,
+				params
+			})
+		});
+		if (!response.ok) throw new Error(`HTTP ${response.status}`);
+		const payload = await response.json();
+		if (payload.error) throw new Error(payload.error.message || "Solana RPC returned an error");
+		const parsedResult = parseResult(payload.result);
+		if (parsedResult === null) throw new Error("Invalid Solana RPC response");
+		return parsedResult;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "unknown Solana RPC error";
+		errors.push(`${rpcUrl}: ${message}`);
+		console.warn("[trails-svm] Solana RPC call failed; trying fallback", {
+			method,
+			rpcUrl,
+			error: message
+		});
+	}
+	throw new Error(`Solana RPC ${method} failed on all configured endpoints: ${errors.join(" | ")}`);
+}
+function createRpcConnection(rpcUrlsOrOptions = {}) {
+	const rpcUrls = Array.isArray(rpcUrlsOrOptions) ? uniqueNonEmpty(rpcUrlsOrOptions) : resolveSolanaRpcUrls(rpcUrlsOrOptions);
+	return {
+		rpcEndpoint: rpcUrls[0],
+		rpcUrls,
+		async getLatestBlockhash(commitment = "finalized") {
+			return callSolanaRpcWithFallback({
+				rpcUrls,
+				method: "getLatestBlockhash",
+				params: [{ commitment }],
+				parseResult: (result) => {
+					if (typeof result !== "object" || result === null || !("value" in result)) return null;
+					const value = result.value;
+					if (typeof value !== "object" || value === null) return null;
+					const blockhash = value.blockhash;
+					const lastValidBlockHeight = value.lastValidBlockHeight;
+					if (typeof blockhash !== "string" || blockhash.length === 0 || typeof lastValidBlockHeight !== "number") return null;
+					return {
+						blockhash,
+						lastValidBlockHeight
+					};
+				}
+			});
+		},
+		async sendRawTransaction(serializedTransaction, options) {
+			const parsedOptions = options || {};
+			const encodedTx = toBase64(serializedTransaction);
+			return callSolanaRpcWithFallback({
+				rpcUrls,
+				method: "sendTransaction",
+				params: [encodedTx, {
+					encoding: "base64",
+					skipPreflight: parsedOptions.skipPreflight ?? false,
+					preflightCommitment: parsedOptions.preflightCommitment ?? "confirmed",
+					maxRetries: parsedOptions.maxRetries ?? 5
+				}],
+				parseResult: (result) => typeof result === "string" && result.length > 0 ? result : null
+			});
+		}
+	};
+}
+//#endregion
+//#region src/walletHelpers.ts
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function isWalletStandardSolanaWallet(value) {
+	if (!isObject(value)) return false;
+	const features = value.features;
+	if (!isObject(features)) return false;
+	const signTransaction = features["solana:signTransaction"];
+	return isObject(signTransaction) && typeof signTransaction.signTransaction === "function";
+}
+function unwrapWalletStandardSolanaWallet(value) {
+	if (isWalletStandardSolanaWallet(value)) return { wallet: value };
+	if (!isObject(value)) return null;
+	const candidate = value;
+	const directWallet = candidate.wallet;
+	if (isWalletStandardSolanaWallet(directWallet)) return {
+		wallet: directWallet,
+		connected: typeof candidate.connected === "boolean" ? candidate.connected : void 0
+	};
+	const adapter = candidate.adapter;
+	const adapterWallet = isObject(adapter) ? adapter.wallet : void 0;
+	if (isWalletStandardSolanaWallet(adapterWallet)) return {
+		wallet: adapterWallet,
+		connected: isObject(adapter) && typeof adapter.connected === "boolean" ? adapter.connected : void 0
+	};
+	return null;
+}
+function findSolanaAccount(wallet) {
+	return wallet.accounts?.find((account) => account.chains?.some((chain) => chain.startsWith("solana:"))) ?? wallet.accounts?.[0] ?? null;
+}
+function isSerializedSolanaWallet(value) {
+	if (!isObject(value)) return false;
+	return typeof value.signSerializedTransaction === "function";
+}
+function isKitWalletSession(value) {
+	if (!isObject(value)) return false;
+	if (typeof value.signTransaction !== "function") return false;
+	if ("wallet" in value || "adapter" in value) return false;
+	const account = value.account;
+	if (!isObject(account)) return false;
+	const address = account.address;
+	return typeof address === "string" || address != null;
+}
+function getKitSessionAddress(session) {
+	const address = session.account?.address;
+	if (typeof address === "string") return address;
+	return address?.toString() ?? null;
+}
+function createKitSessionSolanaWallet({ wallet, connection, connected }) {
+	if (!wallet.signTransaction) return null;
+	const walletAddress = getKitSessionAddress(wallet);
+	if (!walletAddress) throw new Error("Solana wallet session has no account address");
+	return {
+		connected: connected ?? true,
+		publicKey: { toBase58: () => walletAddress },
+		signSerializedTransaction: async (transactionBytes) => {
+			const transaction = getTransactionDecoder().decode(transactionBytes);
+			const signedTransaction = await wallet.signTransaction(transaction);
+			return new Uint8Array(getTransactionEncoder().encode(signedTransaction));
+		},
+		connection,
+		walletIcon: wallet.connector?.icon,
+		walletName: wallet.connector?.name
+	};
+}
+/**
+* Creates a Trails Solana wallet from a Wallet Standard wallet,
+* standard-compatible `@solana/wallet-adapter` adapter, or Kit-style wallet
+* session such as `@solana/react-hooks`' connected `wallet` value.
+*
+* This helper signs serialized Solana transaction bytes without requiring
+* `@solana/web3.js` transaction classes.
+*/
+function createSolanaWallet({ wallet: inputWallet, account: inputAccount, connection, connected, chain }) {
+	if (isSerializedSolanaWallet(inputWallet)) return {
+		...inputWallet,
+		connected: connected ?? inputWallet.connected,
+		connection: connection ?? inputWallet.connection
+	};
+	const unwrapped = unwrapWalletStandardSolanaWallet(inputWallet);
+	if (!unwrapped) {
+		if (isKitWalletSession(inputWallet)) return createKitSessionSolanaWallet({
+			wallet: inputWallet,
+			connection,
+			connected
+		});
+		return null;
+	}
+	const { wallet } = unwrapped;
+	const signTransaction = wallet.features?.["solana:signTransaction"];
+	if (typeof signTransaction?.signTransaction !== "function") throw new Error(`${wallet.name ?? "Solana wallet"} does not support solana:signTransaction`);
+	const account = inputAccount ?? findSolanaAccount(wallet);
+	if (!account) throw new Error(`${wallet.name ?? "Solana wallet"} has no Solana account`);
+	return {
+		connected: connected ?? unwrapped.connected ?? true,
+		publicKey: { toBase58: () => account.address },
+		signSerializedTransaction: async (transactionBytes) => {
+			const [signed] = await signTransaction.signTransaction({
+				account,
+				transaction: transactionBytes,
+				chain: chain ?? account.chains?.find((value) => value.startsWith("solana:"))
+			});
+			if (!signed) throw new Error(`${wallet.name ?? "Solana wallet"} did not sign transaction`);
+			return signed.signedTransaction;
+		},
+		connection,
+		walletName: wallet.name,
+		walletIcon: wallet.icon
+	};
+}
+//#endregion
+//#region src/walletDetection/disconnectPersistence.ts
+const DISCONNECTED_WALLET_IDS_STORAGE_KEY = "0xtrails:svm:disconnected-wallet-ids";
+const disconnectedWalletIdsMemory = /* @__PURE__ */ new Set();
+function readDisconnectedWalletIds() {
+	const walletIds = new Set(disconnectedWalletIdsMemory);
+	if (typeof window === "undefined") return walletIds;
+	try {
+		const stored = window.localStorage?.getItem(DISCONNECTED_WALLET_IDS_STORAGE_KEY);
+		if (!stored) return walletIds;
+		const parsed = JSON.parse(stored);
+		if (!Array.isArray(parsed)) return walletIds;
+		for (const walletId of parsed) if (typeof walletId === "string") walletIds.add(walletId);
+	} catch {}
+	return walletIds;
+}
+function writeDisconnectedWalletIds(walletIds) {
+	disconnectedWalletIdsMemory.clear();
+	for (const walletId of walletIds) disconnectedWalletIdsMemory.add(walletId);
+	if (typeof window === "undefined") return;
+	try {
+		if (walletIds.size === 0) {
+			window.localStorage?.removeItem(DISCONNECTED_WALLET_IDS_STORAGE_KEY);
+			return;
+		}
+		window.localStorage?.setItem(DISCONNECTED_WALLET_IDS_STORAGE_KEY, JSON.stringify([...walletIds]));
+	} catch {}
+}
+/** Remember that the user explicitly disconnected this wallet in the app. */
+function markWalletDisconnected(walletId) {
+	const walletIds = readDisconnectedWalletIds();
+	walletIds.add(walletId);
+	writeDisconnectedWalletIds(walletIds);
+}
+/** Clear persisted disconnect state after an explicit reconnect. */
+function clearWalletDisconnected(walletId) {
+	const walletIds = readDisconnectedWalletIds();
+	walletIds.delete(walletId);
+	writeDisconnectedWalletIds(walletIds);
+}
+/** Wrap disconnect so explicit widget disconnects survive page refresh. */
+function withPersistentSolanaDisconnect(wallet) {
+	if (!wallet?.disconnect) return wallet;
+	const walletId = wallet.walletId?.trim();
+	if (!walletId) return wallet;
+	const disconnect = wallet.disconnect;
+	return {
+		...wallet,
+		disconnect: async () => {
+			markWalletDisconnected(walletId);
+			await disconnect();
+		}
+	};
+}
+//#endregion
+//#region src/walletDetection/walletStandardProvider.ts
+const SOLANA_MAINNET_CHAIN = "solana:mainnet";
+function isSolanaMainnetChain(chain) {
+	return chain === SOLANA_MAINNET_CHAIN || chain?.startsWith("solana:") === true;
+}
+function accountHasSolanaScope(account) {
+	return account.chains?.some(isSolanaMainnetChain) === true;
+}
+function accountIsUnscoped(account) {
+	return !account.chains || account.chains.length === 0;
+}
+function getSolanaAccountFromAccounts(accounts) {
+	return accounts?.find((account) => accountHasSolanaScope(account)) ?? accounts?.find((account) => accountIsUnscoped(account)) ?? accounts?.[0] ?? null;
+}
+function getSolanaAccount(wallet) {
+	return getSolanaAccountFromAccounts(wallet.accounts);
+}
+function isSolanaWallet(wallet) {
+	return wallet.chains?.some(isSolanaMainnetChain) === true || wallet.accounts?.some((account) => account.chains?.some(isSolanaMainnetChain)) === true || typeof wallet.features?.["solana:signTransaction"]?.signTransaction === "function";
+}
+function wrapWalletStandardWallet(wallet) {
+	const connectFeature = wallet.features?.["standard:connect"];
+	if (typeof connectFeature?.connect !== "function") return null;
+	if (typeof (wallet.features?.["solana:signTransaction"])?.signTransaction !== "function") return null;
+	const disconnectFeature = wallet.features?.["standard:disconnect"];
+	const eventsFeature = wallet.features?.["standard:events"];
+	let currentAccount = getSolanaAccount(wallet);
+	const refresh = () => {
+		currentAccount = getSolanaAccount(wallet);
+		provider.account = currentAccount;
+		provider.isConnected = !!currentAccount;
+	};
+	const provider = {
+		wallet,
+		account: currentAccount,
+		isConnected: !!currentAccount,
+		connect: async (opts) => {
+			currentAccount = getSolanaAccountFromAccounts((await connectFeature.connect({ silent: opts?.onlyIfTrusted })).accounts) ?? getSolanaAccount(wallet);
+			provider.account = currentAccount;
+			provider.isConnected = !!currentAccount;
+			if (!currentAccount) throw new Error(`${wallet.name ?? "Solana wallet"} did not return a Solana account`);
+			return currentAccount;
+		},
+		disconnect: async () => {
+			try {
+				await disconnectFeature?.disconnect?.();
+			} finally {
+				currentAccount = null;
+				provider.account = null;
+				provider.isConnected = false;
+			}
+		}
+	};
+	if (typeof eventsFeature?.on === "function") {
+		const unsubscribers = /* @__PURE__ */ new Map();
+		provider.on = (_event, handler) => {
+			const unsubscribe = eventsFeature.on("change", () => {
+				refresh();
+				handler(provider.account);
+			});
+			unsubscribers.set(handler, unsubscribe);
+		};
+		provider.off = (_event, handler) => {
+			unsubscribers.get(handler)?.();
+			unsubscribers.delete(handler);
+		};
+	}
+	return provider;
+}
+function dedupeProviders(providers) {
+	const seen = /* @__PURE__ */ new Set();
+	return providers.filter((provider) => {
+		const id = inferWalletId(provider);
+		if (seen.has(id)) return false;
+		seen.add(id);
+		return true;
+	});
+}
+function listStandardSolanaProviders() {
+	if (typeof window === "undefined") return [];
+	return dedupeProviders(getWallets().get().map((wallet) => wallet).filter(isSolanaWallet).map(wrapWalletStandardWallet).filter((provider) => !!provider));
+}
+function inferWalletLabel(provider) {
+	return provider.wallet.name?.trim() || "Solana wallet";
+}
+function inferWalletId(provider) {
+	return inferWalletLabel(provider).toLowerCase().trim().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "") || "solana-wallet";
+}
+//#endregion
+//#region src/walletDetection/useDetectedSolanaWallet.ts
+const SOLANA_CHAIN = {
+	chainId: SOLANA_MAINNET_CHAIN_ID,
+	name: "Solana",
+	chainType: "SOLANA",
+	nativeCurrency: {
+		name: "Solana",
+		symbol: "SOL",
+		decimals: 9
+	}
+};
+function normalizeWalletId(walletId) {
+	return walletId.endsWith("-solana") ? walletId.slice(0, -7) : walletId;
+}
+function findProviderByWalletId(providers, walletId) {
+	if (!walletId) return null;
+	const normalizedWalletId = normalizeWalletId(walletId);
+	return providers.find((candidate) => {
+		const candidateId = inferWalletId(candidate);
+		return candidateId === walletId || candidateId === normalizedWalletId || normalizeWalletId(candidateId) === normalizedWalletId;
+	}) ?? null;
+}
+function uniqueProviders(providers) {
+	const seen = /* @__PURE__ */ new Set();
+	const unique = [];
+	for (const provider of providers) {
+		if (!provider) continue;
+		const id = inferWalletId(provider);
+		if (seen.has(id)) continue;
+		seen.add(id);
+		unique.push(provider);
+	}
+	return unique;
+}
+function useDetectedSolanaWallet(options = {}) {
+	const enabled = options.enabled ?? true;
+	const silentReconnect = options.silentReconnect ?? true;
+	const preferredWalletId = options.preferredWalletId;
+	const [providers, setProviders] = useState([]);
+	const [provider, setProvider] = useState(null);
+	const [connected, setConnected] = useState(false);
+	const [connecting, setConnecting] = useState(false);
+	const selectedWalletIdRef = useRef(null);
+	const connection = useMemo(() => createRpcConnection({ rpcUrls: options.rpcUrls }), [options.rpcUrls]);
+	useEffect(() => {
+		if (!enabled) {
+			selectedWalletIdRef.current = null;
+			setProviders([]);
+			setProvider(null);
+			setConnected(false);
+			return;
+		}
+		if (typeof window === "undefined") return;
+		let cancelled = false;
+		let reconnectRun = 0;
+		const detectProviders = () => {
+			const detectedProviders = listStandardSolanaProviders();
+			const disconnectedWalletIds = readDisconnectedWalletIds();
+			if (cancelled) return;
+			setProviders(detectedProviders);
+			const preferredProvider = findProviderByWalletId(detectedProviders, preferredWalletId);
+			const currentProvider = findProviderByWalletId(detectedProviders, selectedWalletIdRef.current);
+			const connectedProvider = detectedProviders.find((candidate) => candidate.isConnected && candidate.account && !disconnectedWalletIds.has(inferWalletId(candidate)));
+			const defaultProvider = preferredProvider ?? currentProvider ?? connectedProvider ?? detectedProviders[0] ?? null;
+			setProvider((stateProvider) => {
+				if (!detectedProviders.length) {
+					selectedWalletIdRef.current = null;
+					return null;
+				}
+				const nextProvider = stateProvider ? findProviderByWalletId(detectedProviders, inferWalletId(stateProvider)) ?? defaultProvider : defaultProvider;
+				selectedWalletIdRef.current = nextProvider ? inferWalletId(nextProvider) : null;
+				return nextProvider;
+			});
+			const selectedConnectedProvider = uniqueProviders([
+				preferredProvider,
+				currentProvider,
+				connectedProvider
+			]).find((candidate) => candidate.isConnected && candidate.account && !disconnectedWalletIds.has(inferWalletId(candidate)));
+			if (selectedConnectedProvider?.account) {
+				selectedWalletIdRef.current = inferWalletId(selectedConnectedProvider);
+				setProvider(selectedConnectedProvider);
+				setConnected(true);
+				return;
+			}
+			setConnected(false);
+			if (!silentReconnect) return;
+			const runId = ++reconnectRun;
+			const reconnectCandidates = uniqueProviders([
+				preferredProvider,
+				currentProvider,
+				defaultProvider,
+				...detectedProviders
+			]).filter((candidate) => !disconnectedWalletIds.has(inferWalletId(candidate)));
+			(async () => {
+				for (const candidate of reconnectCandidates) try {
+					await candidate.connect({ onlyIfTrusted: true });
+					if (cancelled || runId !== reconnectRun) return;
+					if (!candidate.account) continue;
+					selectedWalletIdRef.current = inferWalletId(candidate);
+					setProvider(candidate);
+					setConnected(true);
+					return;
+				} catch {}
+			})();
+		};
+		detectProviders();
+		const detectWithDelay = window.setTimeout(detectProviders, 1e3);
+		window.addEventListener("solana#initialized", detectProviders);
+		return () => {
+			cancelled = true;
+			window.clearTimeout(detectWithDelay);
+			window.removeEventListener("solana#initialized", detectProviders);
+		};
+	}, [
+		enabled,
+		preferredWalletId,
+		silentReconnect
+	]);
+	useEffect(() => {
+		if (!enabled || !provider) {
+			setConnected(false);
+			return;
+		}
+		const walletId = inferWalletId(provider);
+		const handleChange = () => {
+			setConnected(provider.isConnected && !!provider.account && !readDisconnectedWalletIds().has(walletId));
+		};
+		provider.on?.("change", handleChange);
+		return () => {
+			provider.off?.("change", handleChange);
+		};
+	}, [enabled, provider]);
+	const connectProvider = useCallback(async (targetProvider) => {
+		setConnecting(true);
+		setConnected(false);
+		try {
+			const account = await targetProvider.connect();
+			const walletId = inferWalletId(targetProvider);
+			clearWalletDisconnected(walletId);
+			selectedWalletIdRef.current = walletId;
+			setProvider(targetProvider);
+			setConnected(!!targetProvider.account);
+			return { publicKey: { toBase58: () => account.address } };
+		} finally {
+			setConnecting(false);
+		}
+	}, []);
+	const connect = useCallback(async (walletId) => {
+		const requestedProvider = findProviderByWalletId(providers, walletId);
+		if (walletId && !requestedProvider) throw new Error(`Solana wallet ${walletId} is not available`);
+		const targetProvider = requestedProvider ?? provider ?? providers[0];
+		if (!targetProvider) throw new Error("No Solana wallet provider is available");
+		return connectProvider(targetProvider);
+	}, [
+		connectProvider,
+		provider,
+		providers
+	]);
+	const disconnect = useCallback(async () => {
+		if (!provider) return;
+		markWalletDisconnected(inferWalletId(provider));
+		selectedWalletIdRef.current = null;
+		try {
+			await provider.disconnect();
+		} finally {
+			setConnected(false);
+		}
+	}, [provider]);
+	return useMemo(() => {
+		if (!provider && providers.length === 0) return null;
+		const selectedProvider = provider ?? providers[0] ?? null;
+		return {
+			...(selectedProvider?.account && connected ? createSolanaWallet({
+				wallet: selectedProvider.wallet,
+				account: selectedProvider.account,
+				connection,
+				connected
+			}) : null) ?? {},
+			connected,
+			connecting,
+			connection,
+			walletId: selectedProvider ? inferWalletId(selectedProvider) : void 0,
+			walletName: selectedProvider ? inferWalletLabel(selectedProvider) : void 0,
+			walletIcon: selectedProvider?.wallet.icon ?? "",
+			availableWallets: providers.map((candidate) => ({
+				walletId: inferWalletId(candidate),
+				walletName: inferWalletLabel(candidate),
+				walletIcon: candidate.wallet.icon ?? ""
+			})),
+			activeChain: SOLANA_CHAIN,
+			connect,
+			disconnect
+		};
+	}, [
+		provider,
+		providers,
+		connected,
+		connecting,
+		connection,
+		connect,
+		disconnect
+	]);
+}
+//#endregion
+//#region src/plugin.tsx
+/**
+* Resolves ordered Solana mainnet RPC endpoints for a wallet.
+* Priority: TrailsProvider `solanaRpcUrl` → wallet connection → public mainnet default.
+*/
+function getWalletSolanaRpcUrls(configuredSolanaRpcUrl, connection) {
+	return getEdgeSolanaRpcUrls([
+		...configuredSolanaRpcUrl ? [configuredSolanaRpcUrl] : [],
+		...connection?.rpcEndpoint ? [connection.rpcEndpoint] : [],
+		...connection?.rpcUrls ?? []
+	]);
+}
+function resolveSolanaEdgeDestinationAddress(options, solanaWallet) {
+	const propAddress = options?.recipient?.trim();
+	if (propAddress && isSolanaAddress(propAddress)) return propAddress;
+	if (solanaWallet?.connected && solanaWallet.publicKey) return solanaWallet.publicKey.toBase58();
+	return null;
+}
+const SOLANA_TOKENS = getSolanaTokens();
+/**
+* Registers the SVM plugin and provides the Solana wallet context.
+* Wrap your app (or TrailsWidget) with this provider to enable Solana edge payments.
+* Composes with other EdgePlugin providers — each appends to the shared registry.
+*/
+function SvmPluginProvider({ account, chain, connected, connection, wallet, rpcUrls, preferredWalletId, silentReconnect, children }) {
+	const existingPlugins = useContext(EdgePluginContext);
+	const { solanaRpcUrl: configuredSolanaRpcUrl } = useTrails();
+	const detectedSolanaWallet = useDetectedSolanaWallet({
+		rpcUrls,
+		preferredWalletId,
+		silentReconnect,
+		enabled: wallet === void 0
+	});
+	const resolvedConnection = useMemo(() => {
+		if (connection) return connection;
+		if (rpcUrls && rpcUrls.length > 0) return createRpcConnection({ rpcUrls });
+	}, [connection, rpcUrls]);
+	const disconnectedSolanaWallet = useMemo(() => ({
+		connected: false,
+		connection: resolvedConnection ?? null,
+		publicKey: null,
+		signSerializedTransaction: void 0,
+		availableWallets: [],
+		connect: null,
+		disconnect: null
+	}), [resolvedConnection]);
+	const resolvedSolanaWallet = useMemo(() => {
+		return withPersistentSolanaDisconnect(wallet !== void 0 ? createSolanaWallet({
+			wallet,
+			account,
+			chain,
+			connected,
+			connection: resolvedConnection
+		}) : detectedSolanaWallet) ?? disconnectedSolanaWallet;
+	}, [
+		account,
+		chain,
+		connected,
+		detectedSolanaWallet,
+		disconnectedSolanaWallet,
+		resolvedConnection,
+		wallet
+	]);
+	const svmPlugin = useMemo(() => ({
+		rail: EDGE_RAIL.SOLANA,
+		supportsChain(fromChainId) {
+			return isSolanaChainId(fromChainId);
+		},
+		getOriginTokens() {
+			return SOLANA_TOKENS;
+		},
+		buildEdgeConfig(fromChainId) {
+			if (!isSolanaChainId(fromChainId)) return null;
+			if (!resolvedSolanaWallet?.connected || !resolvedSolanaWallet.publicKey || typeof resolvedSolanaWallet.signSerializedTransaction !== "function") return null;
+			return createSolanaEdgeOriginConfig({
+				rpcUrls: getWalletSolanaRpcUrls(configuredSolanaRpcUrl, resolvedSolanaWallet.connection),
+				signerPublicKeyBase58: resolvedSolanaWallet.publicKey.toBase58()
+			});
+		},
+		supportsDestinationChain(toChainId) {
+			return isSolanaChainId(toChainId);
+		},
+		getDestinationTokens() {
+			return SOLANA_TOKENS;
+		},
+		buildEdgeDestinationConfig(toChainId, options) {
+			if (!isSolanaChainId(toChainId)) return null;
+			const recipient = resolveSolanaEdgeDestinationAddress(options, resolvedSolanaWallet);
+			if (!recipient) return null;
+			return createSolanaEdgeDestinationConfig({
+				chainId: SOLANA_EDGE_CHAIN_ID,
+				recipient
+			});
+		},
+		async executeDeposit({ providerQuote }) {
+			if (!resolvedSolanaWallet?.connected || !resolvedSolanaWallet.publicKey || typeof resolvedSolanaWallet.signSerializedTransaction !== "function") throw new Error("Solana wallet not connected");
+			return executeRelaySolanaQuote({
+				rpcUrls: getWalletSolanaRpcUrls(configuredSolanaRpcUrl, resolvedSolanaWallet.connection),
+				signerPublicKeyBase58: resolvedSolanaWallet.publicKey.toBase58(),
+				signSerializedTransaction: resolvedSolanaWallet.signSerializedTransaction,
+				walletConnection: resolvedSolanaWallet.connection ?? void 0,
+				providerQuote
+			});
+		}
+	}), [configuredSolanaRpcUrl, resolvedSolanaWallet]);
+	const plugins = useMemo(() => [...existingPlugins, svmPlugin], [existingPlugins, svmPlugin]);
+	useEffect(() => {
+		setSolanaSupportEnabled(true);
+		return () => setSolanaSupportEnabled(false);
+	}, []);
+	return /* @__PURE__ */ jsx(UnifiedWalletProvider, {
+		solanaWallet: resolvedSolanaWallet,
+		children: /* @__PURE__ */ jsx(EdgePluginContext.Provider, {
+			value: plugins,
+			children
+		})
+	});
+}
+//#endregion
+//#region src/svmAdapter.tsx
+/**
+* Creates a Trails wallet adapter for Solana (SVM) edge payments.
+*
+* Provides the Solana wallet context and auto-registers the SVM edge plugin
+* when passed to `TrailsWidget` or `TrailsProvider` via the `adapters` prop.
+*
+* @example
+* ```tsx
+* import { evmAdapter } from "0xtrails"
+* import { svmAdapter } from "@0xtrails/svm"
+*
+* <TrailsWidget adapters={[evmAdapter({ wallets: [...] }), svmAdapter({ wallet })]} />
+* ```
+*/
+function svmAdapter(options) {
+	return {
+		Provider: SvmPluginProvider,
+		providerProps: options,
+		namespaces: ["solana"]
+	};
+}
+//#endregion
+export { ErrEVMStepInSolanaQuote, SvmPluginProvider, clearWalletDisconnected, createSolanaWallet, executeRelaySolanaQuote, readDisconnectedWalletIds, svmAdapter, useDetectedSolanaWallet, withPersistentSolanaDisconnect };