import type { NetworkId, NetworkRpcMap, SolanaGenericTransferRequest, SolanaNativeTransferRequest, SolanaTokenTransferRequest, SolanaTransactionRequest } from '@meshconnect/uwc-types' import { assertSameMessage, isVersionedTransactionBytes } from '@meshconnect/uwc-types' import { VersionedTransaction, PublicKey, Connection, Transaction } from '@solana/web3.js' import type SignClient from '@walletconnect/sign-client' import type { SessionTypes } from '@walletconnect/types' import { isValidNamespacesRequest } from '@walletconnect/utils' import { SOLANA_WC_METHODS } from './solana-methods' import { standardizeSignature } from '../../utils/encoding-utils' import { parseError } from '../../utils/error-utils' import { Buffer } from 'buffer' import base58 from 'bs58' import { serializeWithinSizeLimit } from '@meshconnect/uwc-types' import { SolanaTransactionBuilder } from './solana-transaction-builder' // ed25519 signatures are 64 bytes — reject a malformed one with a clear error. function assertSolanaSignatureLength(signature: Uint8Array): void { if (signature.length !== 64) { throw new Error( 'WalletConnect returned a malformed Solana signature (expected 64 bytes)' ) } } // The WC Solana spec answers signAndSend with `{ signature }`; some wallets answer with the bare // string. The wallet has already broadcast by now, so anything that is not a base58 64-byte // signature returns '' rather than throwing — a throw would report a failure for a transfer that // went through. function signatureFromSignAndSend(result: unknown): string { const signature = typeof result === 'string' ? result : (result as { signature?: unknown } | null)?.signature if (typeof signature !== 'string' || !signature) return '' try { return base58.decode(signature).length === 64 ? signature : '' } catch { return '' } } export class SolanaTransactionService { private builder: SolanaTransactionBuilder constructor(private networkRpcMap: NetworkRpcMap = {}) { this.builder = new SolanaTransactionBuilder() } /** * Send a Solana transaction */ async sendTransaction( client: SignClient, session: SessionTypes.Struct, request: SolanaTransactionRequest, activeNetworkId: string, activeAddress: string ): Promise { try { // Handle different types of Solana transactions if ('tokenMint' in request) { // SPL token transfer return await this.sendSplTokenTransaction( client, session, request as SolanaTokenTransferRequest, activeNetworkId, activeAddress ) } else if ('instructions' in request) { // Generic transaction with instructions return await this.sendGenericTransferWithInstructions( client, session, request as SolanaGenericTransferRequest, activeNetworkId, activeAddress ) } else if ('from' in request) { // Native transfer return await this.sendNativeTransaction( client, session, request as SolanaNativeTransferRequest, activeNetworkId, activeAddress ) } else { throw new Error('Invalid transaction request type') } } catch (error) { throw parseError(error) } } private async sendGenericTransferWithInstructions( client: SignClient, session: SessionTypes.Struct, request: SolanaGenericTransferRequest, activeNetworkId: string, activeAddress: string ) { try { if (!activeNetworkId) { throw new Error('Active network not found') } // Verify the from address matches active address if (request.feePayer !== activeAddress) { throw new Error('Fee payer address does not match connected wallet') } // Blockhash is required if (!request.blockhash) { throw new Error('Blockhash is required for Solana transactions') } let transaction = await this.builder.getVersionedTransaction( new PublicKey(activeAddress), request ) return this.submitTransaction( client, session, transaction, activeNetworkId, activeAddress ) } catch (error) { throw parseError(error) } } private async sendNativeTransaction( client: SignClient, session: SessionTypes.Struct, request: SolanaNativeTransferRequest, activeNetworkId: string, activeAddress: string ) { try { // Verify the from address matches active address if (request.from !== activeAddress) { throw new Error('From address does not match connected wallet') } // Blockhash is required if (!request.blockhash) { throw new Error('Blockhash is required for Solana transactions') } let transaction: Transaction | VersionedTransaction = new Transaction() transaction.recentBlockhash = request.blockhash transaction.feePayer = new PublicKey(request.from) transaction.instructions = await this.builder.buildTransferInstructions(request) // Serialize the transaction for WalletConnect return this.submitTransaction( client, session, transaction, activeNetworkId, activeAddress ) } catch (error) { throw parseError(error) } } private async sendSplTokenTransaction( client: SignClient, session: SessionTypes.Struct, request: SolanaTokenTransferRequest, activeNetworkId: string, activeAddress: string ) { try { if (!activeNetworkId) { throw new Error('Active network not found') } // Verify the from address matches active address if (request.from !== activeAddress) { throw new Error('From address does not match connected wallet') } // Blockhash is required if (!request.blockhash) { throw new Error('Blockhash is required for Solana transactions') } let transaction = await this.builder.getVersionedTransaction( new PublicKey(activeAddress), request ) return this.submitTransaction( client, session, transaction, activeNetworkId, activeAddress ) } catch (error) { throw parseError(error) } } private async submitTransaction( client: SignClient, session: SessionTypes.Struct, transaction: Transaction | VersionedTransaction, activeNetworkId: string, activeAddress: string ) { // Get the chain ID (e.g., "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" for mainnet) const chainId = activeNetworkId let serializedTransaction: string if (transaction instanceof Transaction) { serializedTransaction = transaction .serialize({ verifySignatures: false }) .toString('base64') } else { serializedTransaction = Buffer.from( serializeWithinSizeLimit(transaction) ).toString('base64') } // Only request signAndSend when the wallet approved it for this chain. isValidNamespacesRequest // is the SignClient's own keying-robust approved-methods check. const walletApprovedSignAndSend = isValidNamespacesRequest( session.namespaces, chainId, SOLANA_WC_METHODS.signAndSendTransaction ) if (walletApprovedSignAndSend) { try { // Preferred path: the wallet broadcasts and returns the signature directly. const result = await client.request({ topic: session.topic, chainId, request: { method: SOLANA_WC_METHODS.signAndSendTransaction, params: { transaction: serializedTransaction } } }) return signatureFromSignAndSend(result) } catch (signAndSendError: unknown) { const errorMessage = signAndSendError instanceof Error ? signAndSendError.message : String(signAndSendError) // Only swallow WalletConnect's not-approved rejection for signAndSend specifically: // "Missing or invalid. request() method: solana_signAndSendTransaction". Requiring both // parts lets unrelated "Missing or invalid" errors (params/chain) and user rejections // that merely echo the method name surface instead of triggering a second prompt. const isSignAndSendNotApproved = errorMessage.includes('Missing or invalid') && errorMessage.includes(SOLANA_WC_METHODS.signAndSendTransaction) if (!isSignAndSendNotApproved) { throw signAndSendError } // fall through to sign-then-broadcast as a safety net } } return this.signTransactionAndBroadcast( client, session, transaction, activeNetworkId, activeAddress, serializedTransaction ) } /** * Fallback for wallets that don't support `solana_signAndSendTransaction`: ask the wallet * to sign only, then broadcast the signed tx via our own RPC. Used both when the pre-check * sees the method isn't approved and when an approved signAndSend is rejected at runtime. */ private async signTransactionAndBroadcast( client: SignClient, session: SessionTypes.Struct, transaction: Transaction | VersionedTransaction, activeNetworkId: string, activeAddress: string, serializedTransaction: string ): Promise { const result: { transaction: string } | { signature: string } = await client.request({ topic: session.topic, chainId: activeNetworkId, request: { method: SOLANA_WC_METHODS.signTransaction, params: { transaction: serializedTransaction } } }) if ('signature' in result) { const decoded = base58.decode(result.signature) assertSolanaSignatureLength(decoded) transaction.addSignature( new PublicKey(activeAddress), Buffer.from(decoded) as Buffer & Uint8Array ) } if ('transaction' in result) { const decodedTransaction = Buffer.from(result.transaction, 'base64') if (transaction instanceof VersionedTransaction) { transaction = VersionedTransaction.deserialize( new Uint8Array(decodedTransaction) ) } else { transaction = Transaction.from(decodedTransaction) } } // Get RPC URL from the network RPC map or fall back to public endpoint const rpcUrl = this.networkRpcMap[activeNetworkId as NetworkId] || 'https://alien-newest-vineyard.solana-mainnet.quiknode.pro/ebe5e35661d7edb7a5e48ab84bd9d477e472a40b' const connection = new Connection(rpcUrl) const rawSignature = await connection.sendRawTransaction( transaction.serialize(), { skipPreflight: false, maxRetries: 3, preflightCommitment: 'confirmed' } ) return standardizeSignature(rawSignature) } /** * Sign Solana tx bytes over WalletConnect WITHOUT broadcasting (relay submits). * Bytes in/out (legacy or v0); only deserializes if the wallet returns a bare * signature instead of the full tx. */ async signTransactionBytes( client: SignClient, session: SessionTypes.Struct, serializedTx: Uint8Array, chainId: string, activeAddress: string ): Promise { try { // WalletConnect spec: the transaction param is base64. const serializedBase64 = Buffer.from(serializedTx).toString('base64') const result: { transaction: string } | { signature: string } = await client.request({ topic: session.topic, chainId, request: { method: SOLANA_WC_METHODS.signTransaction, params: { transaction: serializedBase64 } } }) // Full signed tx back (Phantom/Solflare) — verify only a signature was added. if ('transaction' in result) { const returned = new Uint8Array( Buffer.from(result.transaction, 'base64') ) assertSameMessage(serializedTx, returned) return returned } // Bare signature back (legacy WC) — splice it into our original bytes. if ('signature' in result) { const signatureBytes = base58.decode(result.signature) as Uint8Array assertSolanaSignatureLength(signatureBytes) const userPubkey = new PublicKey(activeAddress) if (isVersionedTransactionBytes(serializedTx)) { const tx = VersionedTransaction.deserialize(serializedTx) tx.addSignature(userPubkey, signatureBytes as Uint8Array & Buffer) return tx.serialize() } const tx = Transaction.from(serializedTx) tx.addSignature( userPubkey, Buffer.from(signatureBytes) as Buffer & Uint8Array ) // verifySignatures:false — the relay's fee-payer slot is still unsigned here. return new Uint8Array(tx.serialize({ verifySignatures: false })) } throw new Error( 'WalletConnect returned an unexpected response shape for solana_signTransaction' ) } catch (error) { throw parseError(error) } } }