@meshconnect/uwc-ton-connector 0.2.1 → 0.3.0

package/src/ton-connect-connector.test.ts

@@ -0,0 +1,627 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import type { Network, TonConnectWalletProvider } from '@meshconnect/uwc-types'
+
+const {
+  mockSdkConnect,
+  mockDisconnect,
+  mockOnStatusChange,
+  mockSendTransaction,
+  mockSignData,
+  mockPauseConnection,
+  mockUnPauseConnection,
+  MockTonConnect,
+  MockUserRejectsError,
+  getLastSdkInstance,
+  setNextConnectedState
+} = vi.hoisted(() => {
+  const mockSdkConnect = vi.fn()
+  const mockDisconnect = vi.fn()
+  const mockOnStatusChange = vi.fn()
+  const mockSendTransaction = vi.fn()
+  const mockSignData = vi.fn()
+  const mockPauseConnection = vi.fn()
+  const mockUnPauseConnection = vi.fn()
+
+  class MockUserRejectsError extends Error {
+    constructor(message?: string) {
+      super(message)
+      Object.setPrototypeOf(this, MockUserRejectsError.prototype)
+    }
+  }
+
+  const sdkInstances: { current: MockTonConnect | null } = { current: null }
+  let nextConnectedState = false
+
+  class MockTonConnect {
+    connected = nextConnectedState
+    account: {
+      address: string
+      chain: string
+      walletStateInit: string
+    } | null = null
+    connect = mockSdkConnect
+    disconnect = mockDisconnect
+    onStatusChange = mockOnStatusChange
+    sendTransaction = mockSendTransaction
+    signData = mockSignData
+    getWallets = vi.fn().mockResolvedValue([
+      {
+        appName: 'tonkeeper',
+        universalLink: 'https://app.tonkeeper.com/ton-connect',
+        bridgeUrl: 'https://bridge.tonapi.io/bridge'
+      }
+    ])
+    pauseConnection = mockPauseConnection
+    unPauseConnection = mockUnPauseConnection
+    constructor() {
+      this.connected = nextConnectedState
+      sdkInstances.current = this
+    }
+  }
+
+  return {
+    mockSdkConnect,
+    mockDisconnect,
+    mockOnStatusChange,
+    mockSendTransaction,
+    mockSignData,
+    mockPauseConnection,
+    mockUnPauseConnection,
+    MockTonConnect,
+    MockUserRejectsError,
+    getLastSdkInstance: () => sdkInstances.current,
+    setNextConnectedState: (state: boolean) => {
+      nextConnectedState = state
+    }
+  }
+})
+
+vi.mock('@tonconnect/sdk', () => ({
+  TonConnect: MockTonConnect,
+  UserRejectsError: MockUserRejectsError,
+  toUserFriendlyAddress: (hex: string) =>
+    `UQ_converted_${hex.split(':')[1]?.slice(0, 8)}`
+}))
+
+vi.mock('./ton-transaction-utils', async () => {
+  const actual = await vi.importActual<
+    typeof import('./ton-transaction-utils')
+  >('./ton-transaction-utils')
+  return {
+    ...actual,
+    bocToHash: async (boc: string) => `hash_of_${boc}`
+  }
+})
+
+import { TonConnectConnector } from './ton-connect-connector'
+
+const TON_NETWORK: Network = {
+  internalId: -239,
+  id: 'tvm:-239',
+  namespace: 'tvm',
+  name: 'TON',
+  logoUrl: 'https://example.com/ton.svg',
+  nativeCurrency: { name: 'Toncoin', symbol: 'TON', decimals: 9 },
+  networkType: 'tvm'
+}
+
+const PROVIDER: TonConnectWalletProvider = {
+  supportedNetworkIds: ['tvm:-239'],
+  walletListAppName: 'tonkeeper'
+}
+
+function createConnector() {
+  return new TonConnectConnector({
+    manifestUrl: 'https://example.com/tonconnect-manifest.json'
+  })
+}
+
+function simulateSuccessfulConnect() {
+  mockSdkConnect.mockReturnValue('tc://connect?...')
+  mockOnStatusChange.mockImplementation(callback => {
+    setTimeout(() => {
+      callback({ account: { address: '0:abcdef1234567890' } })
+    }, 10)
+    return vi.fn()
+  })
+}
+
+describe('TonConnectConnector', () => {
+  let connector: TonConnectConnector
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    connector = createConnector()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  describe('constructor', () => {
+    it('stores config and does not create SDK instance eagerly', () => {
+      expect(getLastSdkInstance()).toBeNull()
+    })
+
+    it('accepts optional walletsListSource', () => {
+      const c = new TonConnectConnector({
+        manifestUrl: 'https://example.com/manifest.json',
+        walletsListSource: 'https://example.com/wallets.json'
+      })
+      expect(c).toBeInstanceOf(TonConnectConnector)
+    })
+  })
+
+  describe('connect', () => {
+    it('requires a TonConnectWalletProvider', async () => {
+      await expect(connector.connect(TON_NETWORK)).rejects.toThrow(
+        'TonConnectWalletProvider is required'
+      )
+    })
+
+    it('requires walletListAppName in provider', async () => {
+      const providerNoAppName = {
+        supportedNetworkIds: ['tvm:-239'],
+        walletListAppName: ''
+      } as TonConnectWalletProvider
+      await expect(
+        connector.connect(TON_NETWORK, providerNoAppName)
+      ).rejects.toThrow('walletListAppName is required')
+    })
+
+    it('throws when walletListAppName is not found in SDK wallet list', async () => {
+      simulateSuccessfulConnect()
+      const unknownProvider: TonConnectWalletProvider = {
+        supportedNetworkIds: ['tvm:-239'],
+        walletListAppName: 'unknownWallet'
+      }
+      await expect(
+        connector.connect(TON_NETWORK, unknownProvider)
+      ).rejects.toThrow(
+        "Wallet 'unknownWallet' not found in TonConnect wallet list"
+      )
+    })
+
+    it('creates SDK with NamespacedStorage uwc-ton-remote', async () => {
+      simulateSuccessfulConnect()
+
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      const sdk = getLastSdkInstance()
+      expect(sdk).not.toBeNull()
+    })
+
+    it('calls sdk.connect with universalLink and bridgeUrl', async () => {
+      simulateSuccessfulConnect()
+
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      expect(mockSdkConnect).toHaveBeenCalledWith({
+        universalLink: 'https://app.tonkeeper.com/ton-connect',
+        bridgeUrl: 'https://bridge.tonapi.io/bridge'
+      })
+    })
+
+    it('exposes the connection URI while approval is pending, clears it on success', async () => {
+      // URI is available during the pending window (sdk.connect sets it synchronously
+      // AFTER onStatusChange is registered). It is cleared after the wallet approves
+      // so the QR modal dismisses cleanly.
+      let capturedURI: string | undefined
+
+      mockOnStatusChange.mockImplementation(callback => {
+        // sdk.connect() is called after onStatusChange returns, so read the URI
+        // inside the scheduled callback (by which time sdk.connect has already run).
+        setTimeout(() => {
+          capturedURI = connector.getConnectionURI()
+          callback({ account: { address: '0:abc' } })
+        }, 0)
+        return vi.fn()
+      })
+
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      expect(capturedURI).toBe('tc://connect?...')
+      expect(() => connector.getConnectionURI()).toThrow(
+        'No connection URI available'
+      )
+    })
+
+    it('sets up onStatusChange BEFORE calling sdk.connect', async () => {
+      const callOrder: string[] = []
+
+      mockOnStatusChange.mockImplementation(callback => {
+        callOrder.push('onStatusChange')
+        setTimeout(() => {
+          callback({ account: { address: '0:abcdef1234567890' } })
+        }, 10)
+        return vi.fn()
+      })
+
+      mockSdkConnect.mockImplementation(() => {
+        callOrder.push('connect')
+        return 'tc://uri'
+      })
+
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      expect(callOrder).toEqual(['onStatusChange', 'connect'])
+    })
+
+    it('converts raw address to user-friendly format', async () => {
+      simulateSuccessfulConnect()
+
+      const result = await connector.connect(TON_NETWORK, PROVIDER)
+
+      expect(result.address).toBe('UQ_converted_abcdef12')
+    })
+
+    it('returns correct ConnectorResult shape', async () => {
+      simulateSuccessfulConnect()
+
+      const result = await connector.connect(TON_NETWORK, PROVIDER)
+
+      expect(result).toEqual({
+        networkId: 'tvm:-239',
+        address: 'UQ_converted_abcdef12',
+        availableAddresses: [
+          { address: 'UQ_converted_abcdef12', networkId: 'tvm:-239' }
+        ]
+      })
+    })
+
+    it('rejects when wallet returns null account and cleans up', async () => {
+      mockSdkConnect.mockReturnValue('tc://uri')
+      mockDisconnect.mockResolvedValue(undefined)
+      mockOnStatusChange.mockImplementation(callback => {
+        setTimeout(() => callback(null), 10)
+        return vi.fn()
+      })
+
+      await expect(connector.connect(TON_NETWORK, PROVIDER)).rejects.toThrow(
+        'rejected'
+      )
+
+      // URI cleared and SDK disconnected on rejection
+      expect(() => connector.getConnectionURI()).toThrow(
+        'No connection URI available'
+      )
+      expect(mockDisconnect).toHaveBeenCalled()
+    })
+
+    it('rejects via error callback and cleans up', async () => {
+      mockSdkConnect.mockReturnValue('tc://uri')
+      mockDisconnect.mockResolvedValue(undefined)
+      mockOnStatusChange.mockImplementation((_callback, errorCallback) => {
+        setTimeout(
+          () =>
+            errorCallback({
+              payload: { code: 0, message: 'User rejected the request' }
+            }),
+          10
+        )
+        return vi.fn()
+      })
+
+      await expect(connector.connect(TON_NETWORK, PROVIDER)).rejects.toThrow(
+        'User rejected the request'
+      )
+
+      // URI cleared and SDK disconnected on error callback
+      expect(() => connector.getConnectionURI()).toThrow(
+        'No connection URI available'
+      )
+      expect(mockDisconnect).toHaveBeenCalled()
+    })
+
+    it('times out after 5 minutes and cleans up', async () => {
+      vi.useFakeTimers()
+
+      mockSdkConnect.mockReturnValue('tc://uri')
+      mockOnStatusChange.mockReturnValue(vi.fn())
+      mockDisconnect.mockResolvedValue(undefined)
+
+      const connectPromise = connector.connect(TON_NETWORK, PROVIDER)
+      const resultPromise = connectPromise.catch((e: Error) => e)
+
+      await vi.advanceTimersByTimeAsync(5 * 60 * 1000)
+
+      const error = await resultPromise
+      expect(error).toBeInstanceOf(Error)
+      expect(error.message).toContain('timed out')
+
+      // URI cleared and SDK disconnected on timeout
+      expect(() => connector.getConnectionURI()).toThrow(
+        'No connection URI available'
+      )
+      expect(mockDisconnect).toHaveBeenCalled()
+    })
+
+    it('ignores late timeout after successful connection', async () => {
+      vi.useFakeTimers()
+
+      simulateSuccessfulConnect()
+      mockDisconnect.mockResolvedValue(undefined)
+
+      const connectPromise = connector.connect(TON_NETWORK, PROVIDER)
+      await vi.advanceTimersByTimeAsync(10)
+      await connectPromise
+
+      mockDisconnect.mockClear()
+      await vi.advanceTimersByTimeAsync(5 * 60 * 1000)
+      expect(mockDisconnect).not.toHaveBeenCalled()
+    })
+
+    it('cleans up previous SDK on reconnect', async () => {
+      simulateSuccessfulConnect()
+      mockDisconnect.mockResolvedValue(undefined)
+
+      await connector.connect(TON_NETWORK, PROVIDER)
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      expect(mockDisconnect).toHaveBeenCalled()
+    })
+
+    it('rejects concurrent connect calls while one is in-flight', async () => {
+      mockSdkConnect.mockReturnValue('tc://uri')
+      mockOnStatusChange.mockImplementation(callback => {
+        setTimeout(() => {
+          callback({ account: { address: '0:abcdef1234567890' } })
+        }, 50)
+        return vi.fn()
+      })
+
+      const first = connector.connect(TON_NETWORK, PROVIDER)
+      await expect(connector.connect(TON_NETWORK, PROVIDER)).rejects.toThrow(
+        'already in progress'
+      )
+
+      await first
+    })
+
+    it('disconnects stale session from NamespacedStorage on fresh SDK', async () => {
+      setNextConnectedState(true)
+      mockDisconnect.mockResolvedValue(undefined)
+      simulateSuccessfulConnect()
+
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      expect(mockDisconnect).toHaveBeenCalled()
+      setNextConnectedState(false)
+    })
+
+    it('sets up visibility change listener', async () => {
+      const addEventSpy = vi.spyOn(document, 'addEventListener')
+      simulateSuccessfulConnect()
+
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      expect(addEventSpy).toHaveBeenCalledWith(
+        'visibilitychange',
+        expect.any(Function)
+      )
+      addEventSpy.mockRestore()
+    })
+  })
+
+  describe('getConnectionURI', () => {
+    it('throws before connect', () => {
+      expect(() => connector.getConnectionURI()).toThrow(
+        'No connection URI available'
+      )
+    })
+
+    it('clears URI after successful connect', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+      // URI is consumed on success — getConnectionURI should throw until next connect
+      expect(() => connector.getConnectionURI()).toThrow(
+        'No connection URI available'
+      )
+    })
+  })
+
+  describe('signMessage', () => {
+    it('throws when not connected', async () => {
+      await expect(connector.signMessage!('hello')).rejects.toThrow(
+        'No active TON connection'
+      )
+    })
+
+    it('delegates to executeSignData and returns result', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      mockSignData.mockResolvedValue({
+        signature: 'sig123',
+        timestamp: 1700000000,
+        domain: 'example.com'
+      })
+
+      const result = await connector.signMessage!('test message')
+
+      expect(mockSignData).toHaveBeenCalled()
+      expect(result).toEqual({
+        type: 'tvm',
+        signature: 'sig123',
+        timestamp: 1700000000,
+        domain: 'example.com',
+        payload: { type: 'text', text: 'test message' }
+      })
+    })
+  })
+
+  describe('sendTransaction', () => {
+    it('throws when not connected', async () => {
+      await expect(
+        connector.sendTransaction!({
+          to: 'UQBxyz',
+          amount: '1000000000',
+          from: 'UQBabc'
+        })
+      ).rejects.toThrow('No active TON connection')
+    })
+
+    it('builds transaction, sends via SDK, and returns hash', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      getLastSdkInstance().account = {
+        address: '0:abcdef1234567890',
+        chain: '-239'
+      }
+      mockSendTransaction.mockResolvedValue({ boc: 'te6cckEBAQEA...' })
+
+      const result = await connector.sendTransaction!({
+        to: 'UQBxyz',
+        amount: '1000000000',
+        from: 'UQBabc'
+      })
+
+      expect(mockSendTransaction).toHaveBeenCalled()
+      expect(result).toBe('hash_of_te6cckEBAQEA...')
+    })
+
+    it('uses sdk.account.address as sender raw address', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      getLastSdkInstance().account = {
+        address: '0:sender_raw',
+        chain: '-239'
+      }
+      mockSendTransaction.mockResolvedValue({ boc: 'boc123' })
+
+      await connector.sendTransaction!({
+        to: 'UQBxyz',
+        amount: '500000000',
+        from: 'UQBabc'
+      })
+
+      const txArg = mockSendTransaction.mock.calls[0][0]
+      expect(txArg.from).toBe('0:sender_raw')
+    })
+
+    it('wraps UserRejectsError with clear message', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      getLastSdkInstance().account = { address: '0:abc', chain: '-239' }
+      mockSendTransaction.mockRejectedValue(
+        new MockUserRejectsError('User rejected')
+      )
+
+      await expect(
+        connector.sendTransaction!({
+          to: 'UQBxyz',
+          amount: '1000000000',
+          from: 'UQBabc'
+        })
+      ).rejects.toThrow('rejected')
+    })
+  })
+
+  describe('switchNetwork', () => {
+    it('is a no-op that returns the current address and networkId', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      const result = await connector.switchNetwork(TON_NETWORK)
+
+      expect(result.networkId).toBe('tvm:-239')
+      expect(result.address).toBe('UQ_converted_abcdef12')
+    })
+  })
+
+  describe('disconnect', () => {
+    it('calls sdk.disconnect and clears state', async () => {
+      simulateSuccessfulConnect()
+      mockDisconnect.mockResolvedValue(undefined)
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      await connector.disconnect!()
+
+      expect(mockDisconnect).toHaveBeenCalled()
+    })
+
+    it('does not throw if sdk.disconnect fails', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+      mockDisconnect.mockRejectedValue(new Error('already disconnected'))
+
+      await expect(connector.disconnect!()).resolves.toBeUndefined()
+    })
+
+    it('is safe to call when never connected', async () => {
+      await expect(connector.disconnect!()).resolves.toBeUndefined()
+    })
+
+    it('resets connectInFlight so subsequent connect works after disconnect', async () => {
+      simulateSuccessfulConnect()
+      mockDisconnect.mockResolvedValue(undefined)
+
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      // Manually set flag to simulate a stuck state
+      connector['connectInFlight'] = true
+
+      await connector.disconnect!()
+
+      // Should be able to connect again without "already in progress"
+      simulateSuccessfulConnect()
+      const result = await connector.connect(TON_NETWORK, PROVIDER)
+      expect(result.address).toBeDefined()
+    })
+  })
+
+  describe('destroy', () => {
+    it('disconnects SDK and removes visibility listener', async () => {
+      const removeSpy = vi.spyOn(document, 'removeEventListener')
+      simulateSuccessfulConnect()
+      mockDisconnect.mockResolvedValue(undefined)
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      await connector.destroy()
+
+      expect(mockDisconnect).toHaveBeenCalled()
+      expect(removeSpy).toHaveBeenCalledWith(
+        'visibilitychange',
+        expect.any(Function)
+      )
+      removeSpy.mockRestore()
+    })
+
+    it('is safe to call when never connected', async () => {
+      await expect(connector.destroy()).resolves.toBeUndefined()
+    })
+  })
+
+  describe('visibility handling', () => {
+    it('calls unPauseConnection when page becomes visible', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      Object.defineProperty(document, 'visibilityState', {
+        value: 'visible',
+        writable: true,
+        configurable: true
+      })
+      document.dispatchEvent(new Event('visibilitychange'))
+
+      expect(mockUnPauseConnection).toHaveBeenCalled()
+    })
+
+    it('calls pauseConnection when page becomes hidden', async () => {
+      simulateSuccessfulConnect()
+      await connector.connect(TON_NETWORK, PROVIDER)
+
+      Object.defineProperty(document, 'visibilityState', {
+        value: 'hidden',
+        writable: true,
+        configurable: true
+      })
+      document.dispatchEvent(new Event('visibilitychange'))
+
+      expect(mockPauseConnection).toHaveBeenCalled()
+    })
+  })
+})