@meshconnect/uwc-injected-connector 0.2.0 → 0.2.1

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

@@ -0,0 +1,192 @@
+import { ethers } from 'ethers'
+import type { EthereumProvider } from '../../eip6963-discovery'
+import type {
+  EVMNativeTransferRequest,
+  EVMContractCallRequest,
+  EVMBatchTransactionRequest,
+  BatchTransactionResult,
+  EthereumTransactionRequest
+} from '@meshconnect/uwc-types'
+import { parseError } from '../../utils/error-utils'
+import { EthereumTransactionBuilder } from './ethereum-transaction-builder'
+
+/**
+ * Service for handling Ethereum/EVM transaction operations
+ */
+export class EthereumTransactionService {
+  private builder: EthereumTransactionBuilder
+
+  constructor() {
+    this.builder = new EthereumTransactionBuilder()
+  }
+
+  /**
+   * Send a transaction for Ethereum
+   */
+  async sendTransaction(
+    request: EthereumTransactionRequest,
+    provider: EthereumProvider
+  ): Promise<string> {
+    try {
+      // Handle different types of EVM transactions
+      if ('contractAddress' in request && 'abi' in request) {
+        // Contract call
+        return await this.sendContractCall(
+          provider,
+          request as EVMContractCallRequest
+        )
+      } else if ('calls' in request) {
+        // Batch transaction
+        return await this.sendBatch(
+          provider,
+          request as EVMBatchTransactionRequest
+        )
+      } else if ('amount' in request && typeof request.amount === 'bigint') {
+        // Native transfer
+        return await this.sendNativeTransaction(
+          provider,
+          request as EVMNativeTransferRequest
+        )
+      } else {
+        throw new Error('Invalid transaction request type')
+      }
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Send native token transfer (ETH, BNB, MATIC, etc.)
+   */
+  private async sendNativeTransaction(
+    provider: EthereumProvider,
+    request: EVMNativeTransferRequest
+  ): Promise<string> {
+    try {
+      // Build transaction
+      const tx = await this.builder.getNativeTransaction(request)
+
+      // Create ethers provider and signer
+      const ethersProvider = new ethers.BrowserProvider(provider)
+      const signer = await ethersProvider.getSigner(request.from)
+
+      // Send transaction
+      const response = await signer.sendTransaction(tx)
+
+      // Wait for confirmation
+      const receipt = await response.wait()
+      return receipt ? receipt.hash : ''
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Send smart contract transaction (including ERC-20 transfers)
+   */
+  private async sendContractCall(
+    provider: EthereumProvider,
+    request: EVMContractCallRequest
+  ): Promise<string> {
+    try {
+      // Build transaction
+      const tx = await this.builder.getContractTransaction(request)
+
+      // Create ethers provider and signer
+      const ethersProvider = new ethers.BrowserProvider(provider)
+      const signer = await ethersProvider.getSigner(request.from)
+
+      // Send transaction
+      const response = await signer.sendTransaction(tx)
+
+      // Wait for confirmation
+      const receipt = await response.wait()
+      return receipt ? receipt.hash : ''
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Send batch of transactions (EIP-5792)
+   */
+  private async sendBatch(
+    provider: EthereumProvider,
+    request: EVMBatchTransactionRequest
+  ): Promise<string> {
+    try {
+      // Prepare calls
+      const calls = await Promise.all(
+        request.calls.map(async tx => {
+          if ('contractAddress' in tx && 'abi' in tx) {
+            // Contract call
+            const result = await this.builder.getContractTransaction(
+              tx as EVMContractCallRequest
+            )
+            return {
+              to: result.to ?? '',
+              value: '0x' + (result.value ?? 0n).toString(16),
+              data: result.data
+            }
+          } else if ('amount' in tx && typeof tx.amount === 'bigint') {
+            // Native transfer
+            const result = await this.builder.getNativeTransaction(
+              tx as EVMNativeTransferRequest
+            )
+            return {
+              to: result.to ?? '',
+              value: '0x' + (result.value ?? 0n).toString(16)
+            }
+          } else {
+            throw new Error('Invalid transaction request type')
+          }
+        })
+      )
+
+      // Create ethers provider
+      const ethersProvider = new ethers.BrowserProvider(provider)
+
+      // Send batch transaction
+      const response: { id: string } = await ethersProvider.send(
+        'wallet_sendCalls',
+        [
+          {
+            version: request.version,
+            from: request.from,
+            chainId: request.chainId,
+            atomicRequired: request.atomicRequired,
+            calls: calls
+          }
+        ]
+      )
+
+      // Poll for completion
+      let result: BatchTransactionResult
+      do {
+        result = await ethersProvider.send('wallet_getCallsStatus', [
+          response.id
+        ])
+
+        // Wait 1 second if still pending
+        if (result.status === 100) {
+          await new Promise(resolve => setTimeout(resolve, 1000))
+        }
+      } while (result.status === 100)
+
+      // Check if successful
+      if (result.status !== 200) {
+        throw new Error('Batch transaction failed')
+      }
+
+      // Return first transaction hash
+      const firstReceipt = result.receipts.find(r => r)
+      if (!firstReceipt) {
+        throw new Error('No transaction receipt found')
+      }
+
+      return firstReceipt.transactionHash
+    } catch (error) {
+      parseError(error)
+    }
+  }
+}

package/src/services/{ethereum-wallet-service.ts → ethereum/ethereum-wallet-service.ts}

@@ -1,9 +1,14 @@
-import type { NetworkId, AvailableAddress } from '@meshconnect/uwc-types'
+import type {
+  NetworkId,
+  AvailableAddress,
+  EVMCapabilities,
+  EVMCapabilityStatus
+} from '@meshconnect/uwc-types'
 import type {
   EthereumProvider,
   DetectedWallet as EIP6963DetectedWallet
-} from '../eip6963-discovery'
-import { getAvailableWallets as getEIP6963Wallets } from '../eip6963-discovery'
+} from '../../eip6963-discovery'
+import { getAvailableWallets as getEIP6963Wallets } from '../../eip6963-discovery'
 
 /**
  * Service for managing Ethereum wallet connections
@@ -158,4 +163,52 @@ export class EthereumWalletService {
     this.connectedProvider = null
     this.account = null
   }
+
+  /**
+   * Get wallet capabilities (EIP-5792 support)
+   */
+  async getCapabilities(
+    from: string
+  ): Promise<Record<string, EVMCapabilities>> {
+    if (!this.connectedProvider) {
+      throw new Error('No Ethereum wallet connected')
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let raw: Record<`0x${string}`, Record<string, any>>
+    try {
+      raw = await this.connectedProvider.request({
+        method: 'wallet_getCapabilities',
+        params: [from]
+      })
+    } catch {
+      return {}
+    }
+
+    const result: Record<string, EVMCapabilities> = {}
+
+    for (const [chainId, caps] of Object.entries(raw || {})) {
+      const networkId = `eip155:${Number(chainId)}`
+      result[networkId] = {}
+
+      for (const [capKey, capValue] of Object.entries(caps)) {
+        if (capValue && typeof capValue === 'object') {
+          if (typeof capValue.supported === 'boolean') {
+            result[networkId][capKey as keyof EVMCapabilities] = {
+              status: capValue.supported ? 'supported' : 'unsupported'
+            }
+          } else if (
+            typeof capValue.status === 'string' &&
+            ['supported', 'ready', 'unsupported'].includes(capValue.status)
+          ) {
+            result[networkId][capKey as keyof EVMCapabilities] = {
+              status: capValue.status as EVMCapabilityStatus
+            }
+          }
+        }
+      }
+    }
+
+    return result
+  }
 }

package/src/services/index.ts

@@ -1,7 +1,7 @@
 export { StorageService } from './storage-service'
-export { EthereumWalletService } from './ethereum-wallet-service'
-export { SolanaWalletService } from './solana-wallet-service'
+export { EthereumWalletService } from './ethereum/ethereum-wallet-service'
+export { SolanaWalletService } from './solana/solana-wallet-service'
 export { ConnectionManager } from './connection-manager'
 export { SignatureService } from './signature-service'
 export { TransactionService } from './transaction-service'
-export { EthereumTransactionService } from './ethereum-transaction-service'
+export { EthereumTransactionService } from './ethereum/ethereum-transaction-service'

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
+  ) {
+    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[] => {
+    if (!('states' in request)) {
+      return []
+    }
+
+    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,190 @@
+import { Transaction, Connection } from '@solana/web3.js'
+import type { WalletAdapter } from '@solana/wallet-adapter-base'
+import type {
+  SolanaNativeTransferRequest,
+  NetworkRpcMap,
+  NetworkId,
+  SolanaTokenTransferRequest,
+  SolanaGenericTransferRequest,
+  SolanaTransactionRequest
+} from '@meshconnect/uwc-types'
+import { parseError } from '../../utils/error-utils'
+import { SolanaTransactionBuilder } from './solana-transaction-builder'
+
+/**
+ * Service for handling Solana transaction operations
+ */
+export class SolanaTransactionService {
+  private networkRpcMap: NetworkRpcMap
+  private builder: SolanaTransactionBuilder
+
+  constructor(networkRpcMap: NetworkRpcMap = {}) {
+    this.networkRpcMap = networkRpcMap
+    this.builder = new SolanaTransactionBuilder()
+  }
+
+  /**
+   * Send a transaction for Solana
+   */
+  async sendTransaction(
+    request: SolanaTransactionRequest,
+    adapter: WalletAdapter
+  ): Promise<string> {
+    try {
+      // Handle different types of Solana transactions
+      if ('tokenMint' in request) {
+        return await this.sendSplTokenTransaction(
+          adapter,
+          request as SolanaTokenTransferRequest
+        )
+      } else if ('from' in request) {
+        return await this.sendNativeTransaction(
+          adapter,
+          request as SolanaNativeTransferRequest
+        )
+      } else if ('instructions' in request) {
+        return await this.sendGenericTransferWithInstructions(
+          adapter,
+          request as SolanaGenericTransferRequest
+        )
+      } else {
+        throw new Error('Invalid transaction request type')
+      }
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Send native SOL transfer
+   */
+  private async sendNativeTransaction(
+    adapter: WalletAdapter,
+    request: SolanaNativeTransferRequest,
+    networkId?: NetworkId
+  ): Promise<string> {
+    try {
+      if (!adapter.publicKey) {
+        throw new Error('Wallet not connected')
+      }
+
+      // Verify the from address matches connected wallet
+      if (adapter.publicKey.toBase58() !== request.from) {
+        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')
+      }
+
+      // Create transaction
+      const transaction = new Transaction()
+      transaction.instructions =
+        await this.builder.buildTransferInstructions(request)
+
+      transaction.recentBlockhash = request.blockhash
+      transaction.feePayer = adapter.publicKey
+
+      // Get RPC URL from the network RPC map or fall back to public endpoint
+      const rpcUrl =
+        networkId && this.networkRpcMap[networkId]
+          ? this.networkRpcMap[networkId]
+          : 'https://api.mainnet-beta.solana.com'
+      const connection = new Connection(rpcUrl)
+
+      const signature = await adapter.sendTransaction(transaction, connection)
+      return signature
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Send SPL token transfer
+   */
+  private async sendSplTokenTransaction(
+    adapter: WalletAdapter,
+    request: SolanaTokenTransferRequest,
+    networkId?: NetworkId
+  ): Promise<string> {
+    try {
+      if (!adapter.publicKey) {
+        throw new Error('Wallet not connected')
+      }
+
+      // Verify the from address matches connected wallet
+      if (adapter.publicKey.toBase58() !== request.from) {
+        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')
+      }
+
+      // Create transaction
+      const transaction = new Transaction()
+      transaction.instructions =
+        await this.builder.buildTransferInstructions(request)
+
+      transaction.recentBlockhash = request.blockhash
+      transaction.feePayer = adapter.publicKey
+
+      // Get RPC URL from the network RPC map or fall back to public endpoint
+      const rpcUrl =
+        networkId && this.networkRpcMap[networkId]
+          ? this.networkRpcMap[networkId]
+          : 'https://api.mainnet-beta.solana.com'
+      const connection = new Connection(rpcUrl)
+
+      const signature = await adapter.sendTransaction(transaction, connection)
+      return signature
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Send native SOL transfer
+   */
+  private async sendGenericTransferWithInstructions(
+    adapter: WalletAdapter,
+    request: SolanaGenericTransferRequest,
+    networkId?: NetworkId
+  ): Promise<string> {
+    try {
+      if (!adapter.publicKey) {
+        throw new Error('Wallet not connected')
+      }
+
+      // Verify the from address matches connected wallet
+      if (adapter.publicKey.toBase58() !== request.feePayer) {
+        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')
+      }
+
+      // Create transaction
+      const transaction = await this.builder.getVersionedTransaction(
+        adapter.publicKey,
+        request
+      )
+
+      // Get RPC URL from the network RPC map or fall back to public endpoint
+      const rpcUrl =
+        networkId && this.networkRpcMap[networkId]
+          ? this.networkRpcMap[networkId]
+          : 'https://api.mainnet-beta.solana.com'
+      const connection = new Connection(rpcUrl)
+
+      const signature = await adapter.sendTransaction(transaction, connection)
+      return signature
+    } catch (error) {
+      parseError(error)
+    }
+  }
+}

package/src/services/{solana-wallet-service.ts → solana/solana-wallet-service.ts}

@@ -3,8 +3,8 @@ import type { WalletAdapter } from '@solana/wallet-adapter-base'
 import {
   getSolanaWallets,
   type WalletStandardInfo
-} from '../wallet-standard-discovery'
-import { StorageService } from './storage-service'
+} from '../../wallet-standard-discovery'
+import { StorageService } from '../storage-service'
 
 /**
  * Service for managing Solana wallet connections