@meshconnect/uwc-wallet-connect-connector 0.2.0 → 0.2.2

package/src/services/solana/solana-transaction-builder.ts

@@ -0,0 +1,214 @@
+import {
+  AddressLookupTableAccount,
+  PublicKey,
+  SystemProgram,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
+  type AddressLookupTableState
+} from '@solana/web3.js'
+import type {
+  SolanaNativeTransferRequest,
+  SolanaTokenTransferRequest,
+  SolanaGenericTransferRequest,
+  SolanaAccountMeta,
+  SolanaTransactionRequest
+} from '@meshconnect/uwc-types'
+import {
+  createTransferCheckedInstruction,
+  createAssociatedTokenAccountIdempotentInstruction,
+  getAssociatedTokenAddress,
+  TOKEN_PROGRAM_ID,
+  TOKEN_2022_PROGRAM_ID
+} from '@solana/spl-token'
+import { Buffer } from 'buffer'
+
+/**
+ * Service for handling Solana transaction operations
+ */
+export class SolanaTransactionBuilder {
+  async buildTransferInstructions(
+    request: SolanaTransactionRequest
+  ): Promise<TransactionInstruction[]> {
+    if ('tokenMint' in request) {
+      return await this.buildSplTokenTransferInstructions(
+        request as SolanaTokenTransferRequest
+      )
+    } else if ('instructions' in request) {
+      return await this.buildGenericTransferInstructions(
+        request as SolanaGenericTransferRequest
+      )
+    } else {
+      return [
+        this.buildNativeTransferInstruction(
+          request as SolanaNativeTransferRequest
+        )
+      ]
+    }
+  }
+
+  async getVersionedTransaction(
+    feePayer: PublicKey,
+    request: SolanaTransactionRequest
+  ): Promise<VersionedTransaction> {
+    const lookupTable = this.parseLookupTable(request)
+
+    return new VersionedTransaction(
+      new TransactionMessage({
+        payerKey: feePayer,
+        recentBlockhash: request.blockhash,
+        instructions: await this.buildTransferInstructions(request)
+      }).compileToV0Message(lookupTable)
+    )
+  }
+
+  /**
+   * Build native SOL transfer
+   */
+  private buildNativeTransferInstruction(
+    request: SolanaNativeTransferRequest
+  ): TransactionInstruction {
+    return SystemProgram.transfer({
+      fromPubkey: new PublicKey(request.from),
+      toPubkey: new PublicKey(request.to),
+      lamports: Number(request.amount)
+    })
+  }
+
+  /**
+   * Build SPL Token transfer
+   */
+  private async buildSplTokenTransferInstructions(
+    request: SolanaTokenTransferRequest
+  ): Promise<TransactionInstruction[]> {
+    let instructions: TransactionInstruction[] = []
+
+    // Create Public Keys
+    const mint = new PublicKey(request.tokenMint)
+    const from = new PublicKey(request.from)
+    const to = new PublicKey(request.to)
+
+    const fromTokenAccount = await getAssociatedTokenAddress(
+      mint,
+      from,
+      false,
+      request.tokenProgram
+        ? new PublicKey(request.tokenProgram)
+        : TOKEN_PROGRAM_ID
+    )
+
+    const toTokenAccount = await getAssociatedTokenAddress(
+      mint,
+      to,
+      false,
+      request.tokenProgram
+        ? new PublicKey(request.tokenProgram)
+        : TOKEN_PROGRAM_ID
+    )
+
+    // Create target associated token account
+    instructions.push(
+      createAssociatedTokenAccountIdempotentInstruction(
+        from,
+        toTokenAccount,
+        to,
+        mint,
+        request.tokenProgram
+          ? new PublicKey(request.tokenProgram)
+          : TOKEN_PROGRAM_ID
+      )
+    )
+
+    const programId =
+      request.tokenProgram === TOKEN_2022_PROGRAM_ID.toBase58()
+        ? TOKEN_2022_PROGRAM_ID
+        : TOKEN_PROGRAM_ID
+
+    instructions.push(
+      createTransferCheckedInstruction(
+        fromTokenAccount,
+        mint,
+        toTokenAccount,
+        from,
+        request.amount,
+        request.tokenDecimals,
+        [],
+        programId
+      )
+    )
+
+    return instructions
+  }
+
+  private async buildGenericTransferInstructions(
+    request: SolanaGenericTransferRequest
+  ): Promise<TransactionInstruction[]> {
+    const result: TransactionInstruction[] = []
+
+    const instructions = request.instructions
+    for (let instrIndex = 0; instrIndex < instructions.length; instrIndex++) {
+      const ix = instructions[instrIndex]!
+      const programId = new PublicKey(ix.programId)
+
+      const keys = ix.accounts.map(
+        (meta: SolanaAccountMeta, accountIndex: number) => {
+          if (!meta.pubKey) {
+            throw new Error(
+              `Account at instruction ${instrIndex}, index ${accountIndex} has no pubKey and is not fillable`
+            )
+          }
+
+          const resolvedPubkey: PublicKey = new PublicKey(meta.pubKey)
+          return {
+            pubkey: resolvedPubkey,
+            isSigner: meta.isSigner,
+            isWritable: meta.isWritable
+          }
+        }
+      )
+
+      result.push(
+        new TransactionInstruction({
+          keys,
+          programId,
+          data: Buffer.from(ix.data, 'base64')
+        })
+      )
+    }
+
+    if (request.additionalRequests) {
+      const extraInstructions = await Promise.all(
+        request.additionalRequests.map(req =>
+          this.buildTransferInstructions(req)
+        )
+      )
+
+      result.push(...extraInstructions.flat())
+    }
+
+    return result
+  }
+
+  private parseLookupTable = (
+    request: SolanaTransactionRequest
+  ): AddressLookupTableAccount[] | undefined => {
+    if (!('states' in request)) {
+      return undefined
+    }
+
+    return (request.states ?? []).map(state => {
+      const currentState: AddressLookupTableState = {
+        deactivationSlot: state.deactivationSlot,
+        lastExtendedSlot: state.lastExtendedSlot,
+        lastExtendedSlotStartIndex: state.lastExtendedStartIndex,
+        addresses: [],
+        ...(state.authority && { authority: new PublicKey(state.authority) })
+      }
+
+      return new AddressLookupTableAccount({
+        key: new PublicKey(state.key),
+        state: currentState
+      })
+    })
+  }
+}

package/src/services/solana/solana-transaction-service.ts

@@ -0,0 +1,294 @@
+import type {
+  NetworkId,
+  NetworkRpcMap,
+  SolanaGenericTransferRequest,
+  SolanaNativeTransferRequest,
+  SolanaTokenTransferRequest,
+  SolanaTransactionRequest
+} 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 { standardizeSignature } from '../../utils/encoding-utils'
+import { parseError } from '../../utils/error-utils'
+import { Buffer } from 'buffer'
+import base58 from 'bs58'
+import { SolanaTransactionBuilder } from './solana-transaction-builder'
+
+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<string> {
+    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(
+        new Uint8Array(transaction.serialize())
+      ).toString('base64')
+    }
+
+    try {
+      // First try signAndSendTransaction (preferred method)
+      const result = await client.request({
+        topic: session.topic,
+        chainId,
+        request: {
+          method: 'solana_signAndSendTransaction',
+          params: {
+            transaction: serializedTransaction
+          }
+        }
+      })
+
+      // WalletConnect returns the signature directly for Solana
+      return result as string
+    } catch (signAndSendError: unknown) {
+      const errorMessage =
+        signAndSendError instanceof Error
+          ? signAndSendError.message
+          : String(signAndSendError)
+      // If signAndSendTransaction is not supported, fallback to signTransaction
+      if (
+        errorMessage.includes('solana_signAndSendTransaction') ||
+        errorMessage.includes('Missing or invalid')
+      ) {
+        // Sign the transaction only
+        const result: { transaction: string } | { signature: string } =
+          await client.request({
+            topic: session.topic,
+            chainId,
+            request: {
+              method: 'solana_signTransaction',
+              params: {
+                transaction: serializedTransaction
+              }
+            }
+          })
+
+        if ('signature' in result) {
+          const decoded = base58.decode(result.signature)
+          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)
+      }
+
+      // If it's a different error, throw it
+      throw signAndSendError
+    }
+  }
+}