@meshconnect/web-link-sdk 3.2.14 → 3.2.15

package/src/utils/wallet/WalletStrategy.ts

@@ -0,0 +1,99 @@
+import {
+  WalletBrowserPayload,
+  SignRequestPayload,
+  ChainSwitchPayload,
+  TransferPayload,
+  SmartContractPayload,
+  DisconnectPayload,
+  TransactionBatchPayload,
+  WalletCapabilitiesPayload,
+  SolanaTransferWithInstructionsPayload
+} from '../types'
+
+export interface WalletStrategy {
+  connect(payload: WalletBrowserPayload): Promise<{
+    accounts: string[]
+    chainId: string | number
+    isConnected: boolean
+  }>
+  disconnect(payload: DisconnectPayload): Promise<void>
+  signMessage(payload: SignRequestPayload): Promise<string>
+  switchChain(payload: ChainSwitchPayload): Promise<{
+    chainId: number | string
+    accounts: string[]
+  }>
+  sendNativeTransfer(payload: TransferPayload): Promise<string>
+  sendSmartContractInteraction(payload: SmartContractPayload): Promise<string>
+  sendNativeSmartContractInteraction(
+    payload: SmartContractPayload
+  ): Promise<string>
+  sendTransactionBatch(payload: TransactionBatchPayload): Promise<string>
+  getWalletCapabilities(payload: WalletCapabilitiesPayload): Promise<{
+    atomic: {
+      status: string
+    }
+  }>
+  sendTransactionWithInstructions(
+    payload: SolanaTransferWithInstructionsPayload
+  ): Promise<string>
+  getProviders(): { id: string; type: string; name?: string; icon?: string }[]
+}
+
+export abstract class BaseWalletStrategy implements WalletStrategy {
+  abstract connect(payload: WalletBrowserPayload): Promise<{
+    accounts: string[]
+    chainId: string | number
+    isConnected: boolean
+  }>
+  abstract disconnect(payload: DisconnectPayload): Promise<void>
+  abstract signMessage(payload: SignRequestPayload): Promise<string>
+  abstract switchChain(payload: ChainSwitchPayload): Promise<{
+    chainId: number | string
+    accounts: string[]
+  }>
+  abstract sendNativeTransfer(payload: TransferPayload): Promise<string>
+  abstract sendSmartContractInteraction(
+    payload: SmartContractPayload
+  ): Promise<string>
+  abstract sendNativeSmartContractInteraction(
+    payload: SmartContractPayload
+  ): Promise<string>
+  abstract sendTransactionBatch(
+    payload: TransactionBatchPayload
+  ): Promise<string>
+  abstract getWalletCapabilities(
+    payload: WalletCapabilitiesPayload
+  ): Promise<{ atomic: { status: string } }>
+  abstract getProviders(): {
+    id: string
+    type: string
+    name?: string
+    icon?: string
+  }[]
+  abstract sendTransactionWithInstructions(
+    payload: SolanaTransferWithInstructionsPayload
+  ): Promise<string>
+
+  protected handleError(error: unknown, operation: string): Error {
+    console.error(`${operation} error:`, error)
+    if (error instanceof Error) {
+      return error
+    }
+    return new Error(`Failed to ${operation}`)
+  }
+
+  protected isUserRejection(error: any): boolean {
+    if (!error) return false
+
+    const message = error.message?.toLowerCase() || ''
+    //4001 - user reject, -32603 internal error
+    const errorCodes = [4001, -32603]
+
+    return (
+      message.includes('user rejected') ||
+      message.includes('declined') ||
+      message.includes('cancelled') ||
+      errorCodes.includes(error.code)
+    )
+  }
+}

package/src/utils/wallet/WalletStrategyFactory.ts

@@ -0,0 +1,46 @@
+import { WalletStrategy } from './WalletStrategy'
+import { EVMWalletStrategy } from './EVMWalletStrategy'
+import { SolanaWalletStrategy } from './SolanaWalletStrategy'
+
+export type NetworkType = 'evm' | 'solana'
+
+export class WalletStrategyFactory {
+  private static instance: WalletStrategyFactory
+  private strategies: Map<NetworkType, WalletStrategy>
+
+  private constructor() {
+    this.strategies = new Map()
+    this.strategies.set('evm', new EVMWalletStrategy())
+    this.strategies.set('solana', new SolanaWalletStrategy())
+  }
+
+  public static getInstance(): WalletStrategyFactory {
+    if (!WalletStrategyFactory.instance) {
+      WalletStrategyFactory.instance = new WalletStrategyFactory()
+    }
+    return WalletStrategyFactory.instance
+  }
+
+  public getStrategy(networkType: NetworkType): WalletStrategy {
+    const strategy = this.strategies.get(networkType)
+    if (!strategy) {
+      throw new Error(`No strategy found for network type: ${networkType}`)
+    }
+    return strategy
+  }
+
+  public getAllProviders() {
+    const allProviders: {
+      id: string
+      type: string
+      name?: string
+      icon?: string
+    }[] = []
+
+    this.strategies.forEach(strategy => {
+      allProviders.push(...strategy.getProviders())
+    })
+
+    return allProviders
+  }
+}

package/src/utils/wallet/__tests__/EVMWalletStrategy.test.ts

@@ -0,0 +1,233 @@
+import { EVMWalletStrategy } from '../EVMWalletStrategy'
+import * as evmConnectors from '../../connectors/evm'
+
+jest.mock('../../connectors/evm', () => ({
+  connectToEVMWallet: jest.fn(),
+  disconnectFromEVMWallet: jest.fn(),
+  signEVMMessage: jest.fn(),
+  sendEVMTransaction: jest.fn(),
+  sendEVMTokenTransaction: jest.fn(),
+  switchEVMChain: jest.fn(),
+  findAvailableProviders: jest.fn()
+}))
+
+describe('EVMWalletStrategy', () => {
+  let strategy: EVMWalletStrategy
+
+  beforeEach(() => {
+    strategy = new EVMWalletStrategy()
+    jest.clearAllMocks()
+  })
+
+  describe('connect', () => {
+    const mockPayload = {
+      integrationName: 'MetaMask',
+      targetChainId: '1'
+    }
+
+    it('should successfully connect to wallet', async () => {
+      const mockResult = {
+        accounts: ['0x123'],
+        chainId: 1,
+        isConnected: true
+      }
+      ;(evmConnectors.connectToEVMWallet as jest.Mock).mockResolvedValue(
+        mockResult
+      )
+
+      const result = await strategy.connect(mockPayload)
+      expect(result).toEqual(mockResult)
+      expect(evmConnectors.connectToEVMWallet).toHaveBeenCalledWith(
+        mockPayload.integrationName,
+        parseInt(mockPayload.targetChainId)
+      )
+    })
+
+    it('should handle connection error', async () => {
+      const mockError = new Error('Connection failed')
+      ;(evmConnectors.connectToEVMWallet as jest.Mock).mockResolvedValue(
+        mockError
+      )
+
+      await expect(strategy.connect(mockPayload)).rejects.toThrow(
+        'Connection failed'
+      )
+    })
+  })
+
+  describe('disconnect', () => {
+    it('should successfully disconnect', async () => {
+      await strategy.disconnect({ walletName: 'MetaMask' })
+      expect(evmConnectors.disconnectFromEVMWallet).toHaveBeenCalledWith(
+        'MetaMask'
+      )
+    })
+
+    it('should handle disconnect error', async () => {
+      const mockError = new Error('Disconnect failed')
+      ;(evmConnectors.disconnectFromEVMWallet as jest.Mock).mockResolvedValue(
+        mockError
+      )
+
+      await expect(
+        strategy.disconnect({ walletName: 'MetaMask' })
+      ).rejects.toThrow('Disconnect failed')
+    })
+  })
+
+  describe('signMessage', () => {
+    const mockPayload = {
+      walletName: 'MetaMask',
+      address: '0x123',
+      message: 'Test message'
+    }
+
+    it('should successfully sign message', async () => {
+      const mockSignature = '0xsignature'
+      ;(evmConnectors.signEVMMessage as jest.Mock).mockResolvedValue(
+        mockSignature
+      )
+
+      const result = await strategy.signMessage(mockPayload)
+      expect(result).toBe(mockSignature)
+      expect(evmConnectors.signEVMMessage).toHaveBeenCalledWith(
+        mockPayload.walletName,
+        mockPayload.address,
+        mockPayload.message
+      )
+    })
+
+    it('should handle signing error', async () => {
+      const mockError = new Error('Signing failed')
+      ;(evmConnectors.signEVMMessage as jest.Mock).mockResolvedValue(mockError)
+
+      await expect(strategy.signMessage(mockPayload)).rejects.toThrow(
+        'Signing failed'
+      )
+    })
+  })
+
+  describe('switchChain', () => {
+    const mockPayload = {
+      chainId: 137 // Polygon network
+    }
+
+    it('should successfully switch chain', async () => {
+      const mockResult = {
+        chainId: 137,
+        accounts: ['0x123']
+      }
+      ;(evmConnectors.switchEVMChain as jest.Mock).mockResolvedValue(mockResult)
+
+      const result = await strategy.switchChain(mockPayload)
+      expect(result).toEqual(mockResult)
+      expect(evmConnectors.switchEVMChain).toHaveBeenCalledWith(
+        mockPayload.chainId
+      )
+    })
+
+    it('should handle chain switch error', async () => {
+      const mockError = new Error('Chain switch failed')
+      ;(evmConnectors.switchEVMChain as jest.Mock).mockResolvedValue(mockError)
+
+      await expect(strategy.switchChain(mockPayload)).rejects.toThrow(
+        'Chain switch failed'
+      )
+    })
+  })
+
+  describe('sendNativeTransfer', () => {
+    const mockPayload = {
+      toAddress: '0x456',
+      amount: 1,
+      account: '0x123',
+      decimalPlaces: 18,
+      chainId: 1,
+      network: 'ethereum',
+      gasLimit: 21000,
+      maxFeePerGas: 50000000000,
+      maxPriorityFeePerGas: 1500000000
+    }
+
+    it('should successfully send native transfer', async () => {
+      const mockTxHash = '0xtxhash'
+      ;(evmConnectors.sendEVMTransaction as jest.Mock).mockResolvedValue(
+        mockTxHash
+      )
+
+      const result = await strategy.sendNativeTransfer(mockPayload)
+      expect(result).toBe(mockTxHash)
+      expect(evmConnectors.sendEVMTransaction).toHaveBeenCalledWith(
+        mockPayload.toAddress,
+        BigInt(mockPayload.amount * Math.pow(10, mockPayload.decimalPlaces)),
+        mockPayload.account,
+        mockPayload.gasLimit,
+        mockPayload.maxFeePerGas,
+        mockPayload.maxPriorityFeePerGas
+      )
+    })
+
+    it('should handle transfer error', async () => {
+      const mockError = new Error('Transfer failed')
+      ;(evmConnectors.sendEVMTransaction as jest.Mock).mockResolvedValue(
+        mockError
+      )
+
+      await expect(strategy.sendNativeTransfer(mockPayload)).rejects.toThrow(
+        'Transfer failed'
+      )
+    })
+  })
+
+  describe('sendSmartContractInteraction', () => {
+    const mockPayload = {
+      address: '0xcontract',
+      abi: '["function transfer(address to, uint256 amount)"]',
+      functionName: 'transfer',
+      args: ['0x456', '1000000000000000000'],
+      account: '0x123'
+    }
+
+    it('should successfully send contract interaction', async () => {
+      const mockTxHash = '0xtxhash'
+      ;(evmConnectors.sendEVMTokenTransaction as jest.Mock).mockResolvedValue(
+        mockTxHash
+      )
+
+      const result = await strategy.sendSmartContractInteraction(mockPayload)
+      expect(result).toBe(mockTxHash)
+      expect(evmConnectors.sendEVMTokenTransaction).toHaveBeenCalledWith(
+        mockPayload.address,
+        JSON.parse(mockPayload.abi),
+        mockPayload.functionName,
+        mockPayload.args,
+        mockPayload.account
+      )
+    })
+
+    it('should handle contract interaction error', async () => {
+      const mockError = new Error('Contract interaction failed')
+      ;(evmConnectors.sendEVMTokenTransaction as jest.Mock).mockResolvedValue(
+        mockError
+      )
+
+      await expect(
+        strategy.sendSmartContractInteraction(mockPayload)
+      ).rejects.toThrow('Contract interaction failed')
+    })
+  })
+
+  describe('getProviders', () => {
+    it('should return available providers with correct type', () => {
+      const mockProviders = [
+        { id: 'metamask', name: 'MetaMask', icon: 'icon-url' }
+      ]
+      ;(evmConnectors.findAvailableProviders as jest.Mock).mockReturnValue(
+        mockProviders
+      )
+
+      const result = strategy.getProviders()
+      expect(result).toEqual([{ ...mockProviders[0], type: 'evm' }])
+    })
+  })
+})

package/src/utils/wallet/__tests__/SolanaWalletStrategy.test.ts

@@ -0,0 +1,253 @@
+import { SolanaWalletStrategy } from '../SolanaWalletStrategy'
+import * as solanaConnectors from '../../connectors/solana'
+
+jest.mock('../../connectors/solana', () => ({
+  connectToSolanaWallet: jest.fn(),
+  disconnectFromSolanaWallet: jest.fn(),
+  signSolanaMessage: jest.fn(),
+  sendSOLTransaction: jest.fn(),
+  findAvailableSolanaProviders: jest.fn(),
+  getSolanaProvider: jest.fn()
+}))
+
+describe('SolanaWalletStrategy', () => {
+  let strategy: SolanaWalletStrategy
+
+  beforeEach(() => {
+    strategy = new SolanaWalletStrategy()
+    jest.clearAllMocks()
+  })
+
+  describe('connect', () => {
+    const mockPayload = {
+      integrationName: 'Phantom'
+    }
+
+    it('should successfully connect to wallet', async () => {
+      const mockResult = {
+        accounts: ['solana_address'],
+        chainId: '101',
+        isConnected: true
+      }
+      ;(solanaConnectors.connectToSolanaWallet as jest.Mock).mockResolvedValue(
+        mockResult
+      )
+
+      const result = await strategy.connect(mockPayload)
+      expect(result).toEqual(mockResult)
+      expect(solanaConnectors.connectToSolanaWallet).toHaveBeenCalledWith(
+        mockPayload
+      )
+    })
+
+    it('should handle connection error', async () => {
+      const mockError = new Error('Connection failed')
+      ;(solanaConnectors.connectToSolanaWallet as jest.Mock).mockResolvedValue(
+        mockError
+      )
+
+      await expect(strategy.connect(mockPayload)).rejects.toThrow(
+        'Connection failed'
+      )
+    })
+  })
+
+  describe('disconnect', () => {
+    it('should successfully disconnect', async () => {
+      await strategy.disconnect({ walletName: 'Phantom' })
+      expect(solanaConnectors.disconnectFromSolanaWallet).toHaveBeenCalledWith(
+        'Phantom'
+      )
+    })
+
+    it('should handle disconnect error', async () => {
+      const mockError = new Error('Disconnect failed')
+      ;(
+        solanaConnectors.disconnectFromSolanaWallet as jest.Mock
+      ).mockResolvedValue(mockError)
+
+      await expect(
+        strategy.disconnect({ walletName: 'Phantom' })
+      ).rejects.toThrow('Disconnect failed')
+    })
+  })
+
+  describe('signMessage', () => {
+    const mockPayload = {
+      walletName: 'Phantom',
+      message: 'Test message',
+      address: 'solana_address'
+    }
+
+    it('should successfully sign message', async () => {
+      const mockSignature = 'solana_signature'
+      ;(solanaConnectors.signSolanaMessage as jest.Mock).mockResolvedValue(
+        mockSignature
+      )
+
+      const result = await strategy.signMessage(mockPayload)
+      expect(result).toBe(mockSignature)
+      expect(solanaConnectors.signSolanaMessage).toHaveBeenCalledWith(
+        mockPayload.walletName,
+        mockPayload.message
+      )
+    })
+
+    it('should handle signing error', async () => {
+      const mockError = new Error('Signing failed')
+      ;(solanaConnectors.signSolanaMessage as jest.Mock).mockResolvedValue(
+        mockError
+      )
+
+      await expect(strategy.signMessage(mockPayload)).rejects.toThrow(
+        'Signing failed'
+      )
+    })
+  })
+
+  describe('switchChain', () => {
+    it('should return fixed Solana chain ID', async () => {
+      const result = await strategy.switchChain({ chainId: 1 })
+      expect(result).toEqual({
+        chainId: '101',
+        accounts: []
+      })
+    })
+  })
+
+  describe('sendNativeTransfer', () => {
+    const mockPayload = {
+      toAddress: 'recipient_address',
+      amount: 1,
+      account: 'sender_address',
+      decimalPlaces: 9,
+      walletName: 'Phantom',
+      blockhash: 'test_blockhash',
+      chainId: 101,
+      network: 'solana',
+      tokenProgram: 'token_program_id'
+    }
+
+    it('should successfully send native transfer', async () => {
+      const mockTxHash = 'tx_hash'
+      ;(solanaConnectors.sendSOLTransaction as jest.Mock).mockResolvedValue(
+        mockTxHash
+      )
+
+      const result = await strategy.sendNativeTransfer(mockPayload)
+      expect(result).toBe(mockTxHash)
+      expect(solanaConnectors.sendSOLTransaction).toHaveBeenCalledWith({
+        toAddress: mockPayload.toAddress,
+        amount: BigInt(
+          mockPayload.amount * Math.pow(10, mockPayload.decimalPlaces)
+        ),
+        fromAddress: mockPayload.account,
+        blockhash: mockPayload.blockhash,
+        walletName: mockPayload.walletName
+      })
+    })
+
+    it('should handle transfer error', async () => {
+      const mockError = new Error('Transfer failed')
+      ;(solanaConnectors.sendSOLTransaction as jest.Mock).mockResolvedValue(
+        mockError
+      )
+
+      await expect(strategy.sendNativeTransfer(mockPayload)).rejects.toThrow(
+        'Transfer failed'
+      )
+    })
+  })
+
+  describe('sendSmartContractInteraction', () => {
+    const mockPayload = {
+      address: 'token_mint_address',
+      abi: '[]',
+      functionName: 'transfer',
+      args: ['recipient_address', 1000000n, 6],
+      account: 'sender_address',
+      walletName: 'Phantom',
+      blockhash: 'test_blockhash',
+      tokenProgram: 'token_program_id'
+    }
+
+    it('should successfully send token transfer', async () => {
+      const mockTxHash = 'tx_hash'
+      const mockPublicKey = { toString: () => mockPayload.account }
+      ;(solanaConnectors.getSolanaProvider as jest.Mock).mockReturnValue({
+        publicKey: mockPublicKey
+      })
+      ;(solanaConnectors.sendSOLTransaction as jest.Mock).mockResolvedValue(
+        mockTxHash
+      )
+
+      const result = await strategy.sendSmartContractInteraction(mockPayload)
+      expect(result).toBe(mockTxHash)
+      expect(solanaConnectors.sendSOLTransaction).toHaveBeenCalledWith({
+        toAddress: mockPayload.args[0],
+        amount: mockPayload.args[1],
+        fromAddress: mockPayload.account,
+        blockhash: mockPayload.blockhash,
+        createATA: false,
+        tokenProgram: mockPayload.tokenProgram,
+        walletName: mockPayload.walletName,
+        tokenMint: mockPayload.address,
+        tokenDecimals: mockPayload.args[2]
+      })
+    })
+
+    it('should handle missing sender address', async () => {
+      ;(solanaConnectors.getSolanaProvider as jest.Mock).mockReturnValue({
+        publicKey: null
+      })
+
+      await expect(
+        strategy.sendSmartContractInteraction({
+          ...mockPayload,
+          account: ''
+        })
+      ).rejects.toThrow('Sender account address is required')
+    })
+
+    it('should handle missing blockhash', async () => {
+      const mockPublicKey = { toString: () => mockPayload.account }
+      ;(solanaConnectors.getSolanaProvider as jest.Mock).mockReturnValue({
+        publicKey: mockPublicKey
+      })
+
+      await expect(
+        strategy.sendSmartContractInteraction({
+          ...mockPayload,
+          blockhash: ''
+        })
+      ).rejects.toThrow('Blockhash is required for Solana transactions')
+    })
+  })
+
+  describe('getProviders', () => {
+    it('should return available providers with correct type', () => {
+      const mockProviders = {
+        phantom: true,
+        solflare: true
+      }
+      ;(
+        solanaConnectors.findAvailableSolanaProviders as jest.Mock
+      ).mockReturnValue(mockProviders)
+
+      const result = strategy.getProviders()
+      expect(result).toEqual([
+        { id: 'phantom', type: 'solana' },
+        { id: 'solflare', type: 'solana' }
+      ])
+    })
+
+    it('should handle empty providers', () => {
+      ;(
+        solanaConnectors.findAvailableSolanaProviders as jest.Mock
+      ).mockReturnValue({})
+
+      const result = strategy.getProviders()
+      expect(result).toEqual([])
+    })
+  })
+})

package/src/utils/wallet/__tests__/WalletStrategy.test.ts

@@ -0,0 +1,77 @@
+import { BaseWalletStrategy } from '../WalletStrategy'
+
+// Create a concrete implementation for testing
+class TestWalletStrategy extends BaseWalletStrategy {
+  connect = jest.fn()
+  disconnect = jest.fn()
+  signMessage = jest.fn()
+  switchChain = jest.fn()
+  sendNativeTransfer = jest.fn()
+  sendSmartContractInteraction = jest.fn()
+  getProviders = jest.fn()
+  sendTransactionBatch = jest.fn()
+}
+
+describe('BaseWalletStrategy', () => {
+  let strategy: TestWalletStrategy
+
+  beforeEach(() => {
+    strategy = new TestWalletStrategy()
+  })
+
+  describe('handleError', () => {
+    it('should return the error if it is an Error instance', () => {
+      const error = new Error('Test error')
+      // @ts-expect-error - accessing protected method for testing
+      const result = strategy.handleError(error, 'test operation')
+      expect(result).toBe(error)
+    })
+
+    it('should create a new Error if input is not an Error instance', () => {
+      const errorString = 'string error'
+      // @ts-expect-error - accessing protected method for testing
+      const result = strategy.handleError(errorString, 'test operation')
+      expect(result).toBeInstanceOf(Error)
+      expect(result.message).toBe('Failed to test operation')
+    })
+  })
+
+  describe('isUserRejection', () => {
+    it('should return true for user rejection error code 4001', () => {
+      // @ts-expect-error - accessing protected method for testing
+      expect(strategy.isUserRejection({ code: 4001 })).toBe(true)
+    })
+
+    it('should return true for user rejection error code -32603', () => {
+      // @ts-expect-error - accessing protected method for testing
+      expect(strategy.isUserRejection({ code: -32603 })).toBe(true)
+    })
+
+    it('should return true for rejection message patterns', () => {
+      const rejectionMessages = [
+        { message: 'User rejected' },
+        { message: 'Transaction declined' },
+        { message: 'Operation cancelled' }
+      ]
+
+      rejectionMessages.forEach(error => {
+        // @ts-expect-error - accessing protected method for testing
+        expect(strategy.isUserRejection(error)).toBe(true)
+      })
+    })
+
+    it('should return false for other errors', () => {
+      const nonRejectionErrors = [
+        { code: 5000 },
+        { message: 'Network error' },
+        null,
+        undefined
+      ]
+
+      nonRejectionErrors.forEach(error => {
+        // @ts-expect-error - accessing protected method for testing
+        expect(strategy.isUserRejection(error)).toBe(false)
+      })
+    })
+  })
+})