@meshconnect/uwc-wallet-connect-connector 0.2.0

package/src/utils/account-utils.ts

@@ -0,0 +1,116 @@
+import type { NetworkId, Namespace } from '@meshconnect/uwc-types'
+
+/**
+ * Parse a WalletConnect account string into its components
+ * Account format: "namespace:chainId:address"
+ * Example: "eip155:1:0x1234..." or "solana:mainnet:ABC123..."
+ */
+export function parseAccount(account: string): {
+  namespace: Namespace
+  chainId: string
+  networkId: NetworkId
+  address: string
+} {
+  const parts = account.split(':')
+  if (parts.length < 3) {
+    throw new Error(`Invalid account format: ${account}`)
+  }
+
+  const namespace = parts[0] as Namespace
+  const chainId = parts[1]!
+  const networkId = `${namespace}:${chainId}` as NetworkId
+  // Handle addresses that might contain colons (like some Solana addresses)
+  const address = parts.slice(2).join(':')
+
+  return {
+    namespace,
+    chainId,
+    networkId,
+    address
+  }
+}
+
+/**
+ * Build a WalletConnect account string from components
+ */
+export function buildAccount(
+  namespace: Namespace,
+  chainId: string,
+  address: string
+): string {
+  return `${namespace}:${chainId}:${address}`
+}
+
+/**
+ * Extract namespace from a network ID
+ * Example: "eip155:1" -> "eip155"
+ */
+export function getNamespaceFromNetworkId(networkId: NetworkId): Namespace {
+  const [namespace] = networkId.split(':')
+  return namespace as Namespace
+}
+
+/**
+ * Extract chain ID from a network ID
+ * Example: "eip155:1" -> "1"
+ */
+export function getChainIdFromNetworkId(networkId: NetworkId): string {
+  const [, chainId] = networkId.split(':')
+  return chainId || ''
+}
+
+/**
+ * Find an account in session namespaces that matches the given network and address
+ */
+export function findAccountInNamespaces(
+  namespaces: Record<string, any>,
+  targetNetworkId: NetworkId,
+  targetAddress: string
+): string | null {
+  for (const [, namespaceData] of Object.entries(namespaces)) {
+    for (const account of namespaceData.accounts || []) {
+      const { networkId, address } = parseAccount(account)
+      if (networkId === targetNetworkId && address === targetAddress) {
+        return account
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Extract all accounts from session namespaces
+ */
+export function extractAccountsFromNamespaces(
+  namespaces: Record<string, any>
+): Array<{
+  account: string
+  namespace: Namespace
+  chainId: string
+  networkId: NetworkId
+  address: string
+}> {
+  const accounts: Array<{
+    account: string
+    namespace: Namespace
+    chainId: string
+    networkId: NetworkId
+    address: string
+  }> = []
+
+  Object.entries(namespaces).forEach(([, namespaceData]) => {
+    ;(namespaceData.accounts || []).forEach((account: string) => {
+      try {
+        const parsed = parseAccount(account)
+        accounts.push({
+          account,
+          ...parsed
+        })
+      } catch {
+        // Skip invalid accounts
+      }
+    })
+  })
+
+  return accounts
+}

package/src/utils/encoding-utils.ts

@@ -0,0 +1,32 @@
+import bs58 from 'bs58'
+
+/**
+ * Encode a string message to base58 format (used for Solana message signing)
+ */
+export const base58Encode = (message: string) => {
+  // Use TextEncoder for browser compatibility
+  const encoder = new TextEncoder()
+  const messageBytes = encoder.encode(message)
+  return bs58.encode(messageBytes)
+}
+
+export const standardizeSignature = (
+  rawSignature: string | Uint8Array
+): string => {
+  // First ensure we have a string
+  let signature =
+    typeof rawSignature === 'string' ? rawSignature : bs58.encode(rawSignature)
+
+  // If signature is longer than standard 88 chars, decode and re-encode
+  if (signature.length > 88) {
+    try {
+      const bytes = bs58.decode(signature)
+      const truncatedBytes = bytes.slice(0, 64)
+      signature = bs58.encode(truncatedBytes)
+    } catch {
+      throw new Error('Failed to normalize signature')
+    }
+  }
+
+  return signature
+}

package/src/utils/error-utils.ts

@@ -0,0 +1,62 @@
+import type { WalletError } from '@meshconnect/uwc-types'
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+
+/**
+ * Parse an error and throw a WalletConnectorError
+ * Detects if the error is a user rejection or an unknown error
+ */
+export function parseError(error: unknown): never {
+  let message: string
+  let isRejected = false
+
+  // Handle different error formats
+  if (error && typeof error === 'object') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const errorObj = error as any
+
+    // Check for EIP-1193 error code
+    if (errorObj.code === 4001 || errorObj.code === 'ACTION_REJECTED') {
+      isRejected = true
+    }
+
+    // Extract message
+    if (errorObj.message) {
+      message = errorObj.message
+    } else if (errorObj.error?.message) {
+      message = errorObj.error.message
+    } else {
+      message = String(error)
+    }
+  } else {
+    message = String(error)
+  }
+
+  // If not already marked as rejected, check message patterns
+  if (!isRejected) {
+    const rejectionPatterns = [
+      'user rejected',
+      'user denied',
+      'user cancelled',
+      'user canceled',
+      'rejected by user',
+      'denied by user',
+      'cancelled by user',
+      'canceled by user',
+      'user disapproved',
+      'user declined',
+      'action_rejected'
+    ]
+
+    const lowerMessage = message.toLowerCase()
+    isRejected = rejectionPatterns.some(pattern =>
+      lowerMessage.includes(pattern.toLowerCase())
+    )
+  }
+
+  const walletError: WalletError = {
+    type: isRejected ? 'rejected' : 'unknown',
+    message
+  }
+
+  throw new WalletConnectorError(walletError)
+}

package/src/utils/solana-transactions.ts

@@ -0,0 +1,24 @@
+import type { SolanaNativeTransferRequest } from '@meshconnect/uwc-types'
+import {
+  PublicKey,
+  SystemProgram,
+  Transaction,
+  VersionedTransaction
+} from '@solana/web3.js'
+
+export function getSolanaTransaction(params: SolanaNativeTransferRequest) {
+  if (!params.blockhash) {
+    throw new Error('Blockhash is required for Solana transactions')
+  }
+
+  const transaction: Transaction | VersionedTransaction = new Transaction().add(
+    SystemProgram.transfer({
+      fromPubkey: new PublicKey(params.from),
+      toPubkey: new PublicKey(params.to),
+      lamports: Number(params.amount)
+    })
+  )
+  transaction.recentBlockhash = params.blockhash
+  transaction.feePayer = new PublicKey(params.from)
+  return transaction
+}

package/src/wallet-connect-connector.ts

@@ -0,0 +1,83 @@
+import type {
+  Network,
+  Connector,
+  ConnectorResult,
+  SwitchNetworkResult,
+  WalletConnectConfig,
+  WalletConnectProvider,
+  TransactionRequest,
+  TransactionResult,
+  NetworkRpcMap
+} from '@meshconnect/uwc-types'
+import { WalletConnectClient } from './services/walletconnect-client'
+import { ConnectionService } from './services/connection-service'
+import { NetworkSwitchService } from './services/network-switch-service'
+import { SignatureService } from './services/signature-service'
+import { TransactionService } from './services/transaction-service'
+
+export class WalletConnectConnector implements Connector {
+  private walletConnectClient: WalletConnectClient
+  private connectionService: ConnectionService
+  private networkSwitchService: NetworkSwitchService
+  private signatureService: SignatureService
+  private transactionService: TransactionService
+  private networkRpcMap: NetworkRpcMap
+
+  constructor(config: WalletConnectConfig, networkRpcMap: NetworkRpcMap = {}) {
+    this.walletConnectClient = new WalletConnectClient(config)
+    this.networkRpcMap = networkRpcMap
+    this.connectionService = new ConnectionService(this.walletConnectClient)
+    this.networkSwitchService = new NetworkSwitchService(
+      this.walletConnectClient,
+      this.connectionService
+    )
+    this.signatureService = new SignatureService(
+      this.walletConnectClient,
+      this.connectionService
+    )
+    this.transactionService = new TransactionService(
+      this.walletConnectClient,
+      this.connectionService,
+      this.networkRpcMap
+    )
+  }
+
+  async connect(
+    network: Network,
+    provider?: WalletConnectProvider
+  ): Promise<ConnectorResult> {
+    if (!provider) {
+      throw new Error(
+        'WalletConnectProvider is required for WalletConnect connection'
+      )
+    }
+
+    return this.connectionService.connect(network, provider)
+  }
+
+  getConnectionURI(): string {
+    const uri = this.connectionService.getConnectionURI()
+    if (!uri) {
+      throw new Error('No connection URI available. Call connect() first.')
+    }
+    return uri
+  }
+
+  async disconnect(): Promise<void> {
+    return this.connectionService.disconnect()
+  }
+
+  async switchNetwork(network: Network): Promise<SwitchNetworkResult> {
+    return this.networkSwitchService.switchNetwork(network)
+  }
+
+  async signMessage(message: string): Promise<string> {
+    return this.signatureService.signMessage(message)
+  }
+
+  async sendTransaction(
+    request: TransactionRequest
+  ): Promise<TransactionResult> {
+    return this.transactionService.sendTransaction(request)
+  }
+}