@meshconnect/uwc-tron-connector 0.1.0

package/src/tron-connector.test.ts

@@ -0,0 +1,612 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import type { Network, TronWalletId } from '@meshconnect/uwc-types'
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+import { TronConnector } from './tron-connector'
+import { encodeTrc20TransferParams } from './rest/abi'
+
+// Build the raw_data shape the full node returns, so the connector's
+// "built tx matches request" verification (before signing) passes for the
+// happy path. Mismatching any field simulates a tampered/MITM endpoint.
+const nativeRawData = (from: string, to: string, amount: number) => ({
+  contract: [
+    {
+      type: 'TransferContract',
+      parameter: { value: { owner_address: from, to_address: to, amount } }
+    }
+  ]
+})
+const trc20RawData = (
+  from: string,
+  contractAddress: string,
+  to: string,
+  amount: number
+) => ({
+  contract: [
+    {
+      type: 'TriggerSmartContract',
+      parameter: {
+        value: {
+          owner_address: from,
+          contract_address: contractAddress,
+          data: 'a9059cbb' + encodeTrc20TransferParams(to, amount)
+        }
+      }
+    }
+  ]
+})
+
+function makeNetwork(id: Network['id'], name = 'Tron'): Network {
+  return {
+    internalId: 1,
+    id,
+    namespace: 'tron',
+    name,
+    logoUrl: '',
+    nativeCurrency: { name: 'Tron', symbol: 'TRX', decimals: 6 },
+    networkType: 'tron'
+  }
+}
+const MAINNET = makeNetwork('tron:0x2b6653dc', 'Tron Mainnet')
+const SHASTA = makeNetwork('tron:0x94a9059e', 'Shasta')
+
+// ---- injected-provider stubs -------------------------------------------------
+
+function makeProvider(address: string | null) {
+  const handlers = new Map<string, Array<(...a: unknown[]) => void>>()
+  return {
+    tronWeb: {
+      defaultAddress: { base58: address },
+      trx: {
+        sign: vi.fn(async (tx: object) => ({ ...tx, signature: ['SIG'] })),
+        signMessageV2: vi.fn(async () => '0xsignature')
+      }
+    },
+    request: vi.fn(async () => ({ code: 200 })),
+    on: vi.fn((event: string, handler: (...a: unknown[]) => void) => {
+      const list = handlers.get(event) ?? []
+      list.push(handler)
+      handlers.set(event, list)
+    }),
+    removeListener: vi.fn(
+      (event: string, handler: (...a: unknown[]) => void) => {
+        handlers.set(
+          event,
+          (handlers.get(event) ?? []).filter(h => h !== handler)
+        )
+      }
+    ),
+    // Test-only: fire an event the way a wallet would.
+    emit(event: string, payload?: unknown) {
+      for (const h of handlers.get(event) ?? []) h(payload)
+    }
+  }
+}
+type Provider = ReturnType<typeof makeProvider>
+
+const PATHS: Record<string, string[]> = {
+  tronlink: ['tronLink'],
+  okx: ['okxwallet', 'tronLink'],
+  trust: ['trustWallet', 'tronLink'],
+  bitget: ['bitkeep', 'tronLink'],
+  tokenpocket: ['tokenpocket', 'tron']
+}
+
+function install(walletId: string, provider: Provider): void {
+  const path = PATHS[walletId]!
+  let node = window as unknown as Record<string, unknown>
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i]!
+    if (!node[key]) node[key] = {}
+    node = node[key] as Record<string, unknown>
+  }
+  node[path[path.length - 1]!] = provider
+}
+
+function clearWindow(): void {
+  const w = window as unknown as Record<string, unknown>
+  for (const key of [
+    'tronLink',
+    'tron',
+    'okxwallet',
+    'trustWallet',
+    'trustwallet',
+    'bitkeep',
+    'tokenpocket'
+  ]) {
+    delete w[key]
+  }
+}
+
+// ---- fetch queue -------------------------------------------------------------
+
+let fetchQueue: unknown[] = []
+function enqueue(...bodies: unknown[]): void {
+  fetchQueue.push(...bodies)
+}
+
+beforeEach(() => {
+  clearWindow()
+  fetchQueue = []
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(async () => {
+      const body = fetchQueue.shift()
+      return {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => body ?? {}
+      }
+    })
+  )
+})
+afterEach(() => {
+  clearWindow()
+  vi.unstubAllGlobals()
+})
+
+// Short probe timeouts keep "absent wallet" paths from waiting the full default.
+const fastConfig = (enabledWallets: TronWalletId[]) => ({
+  enabledWallets,
+  readyStateTimeoutMs: 100,
+  discoveryTimeoutMs: 40,
+  readyStatePollIntervalMs: 10
+})
+
+describe('getAvailableWallets', () => {
+  it('returns only enabled wallets that are injected', async () => {
+    install('tronlink', makeProvider('TtronlinkAddr'))
+    install('okx', makeProvider('TokxAddr'))
+    const c = new TronConnector(fastConfig(['tronlink', 'okx', 'trust']))
+    const result = await c.getAvailableWallets('tron')
+    expect(result.map(r => r.uuid).sort()).toEqual(['okx', 'tronlink'])
+  })
+
+  it('filters by expectedWallets when supplied', async () => {
+    install('tronlink', makeProvider('T1'))
+    install('okx', makeProvider('T2'))
+    const c = new TronConnector(fastConfig(['tronlink', 'okx']))
+    const result = await c.getAvailableWallets('tron', [
+      { id: 'okx', name: 'OKX', metadata: {} }
+    ])
+    expect(result.map(r => r.uuid)).toEqual(['okx'])
+  })
+
+  it('returns [] for a non-tron namespace', async () => {
+    const c = new TronConnector(fastConfig(['tronlink']))
+    expect(await c.getAvailableWallets('eip155')).toEqual([])
+  })
+
+  it('preserves a stable order (matches the registry, not probe timing)', async () => {
+    install('tronlink', makeProvider('T1'))
+    install('okx', makeProvider('T2'))
+    install('trust', makeProvider('T3'))
+    const c = new TronConnector(fastConfig(['trust', 'tronlink', 'okx']))
+    // resolveAllowedIds walks ALL_TRON_WALLET_IDS order: tronlink, okx, trust.
+    const result = await c.getAvailableWallets('tron')
+    expect(result.map(r => r.uuid)).toEqual(['tronlink', 'okx', 'trust'])
+  })
+
+  it('detects Trust at both window.trustWallet and window.trustwallet', async () => {
+    // Capital-W (repo canonical) — install() uses PATHS.trust = trustWallet.
+    install('trust', makeProvider('TtrustAddr'))
+    let c = new TronConnector(fastConfig(['trust']))
+    expect((await c.getAvailableWallets('tron')).map(r => r.uuid)).toEqual([
+      'trust'
+    ])
+
+    clearWindow()
+    // Lowercase fallback.
+    ;(window as unknown as Record<string, unknown>)['trustwallet'] = {
+      tronLink: makeProvider('TtrustAddr')
+    }
+    c = new TronConnector(fastConfig(['trust']))
+    expect((await c.getAvailableWallets('tron')).map(r => r.uuid)).toEqual([
+      'trust'
+    ])
+  })
+})
+
+describe('connect', () => {
+  it('connects an enabled, installed wallet and returns the address', async () => {
+    install('tronlink', makeProvider('TtronlinkAddr'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    const result = await c.connect(MAINNET, { uuid: 'tronlink' })
+    expect(result.networkId).toBe('tron:0x2b6653dc')
+    expect(result.address).toBe('TtronlinkAddr')
+    expect(result.availableAddresses).toHaveLength(1)
+  })
+
+  it('throws when the wallet is not enabled', async () => {
+    install('okx', makeProvider('T'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(c.connect(MAINNET, { uuid: 'okx' })).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+
+  it('throws on an unknown wallet id', async () => {
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(
+      c.connect(MAINNET, { uuid: 'phantom' })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('throws when no wallet id is provided', async () => {
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(c.connect(MAINNET)).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+
+  it('throws on a non-tron network', async () => {
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(
+      c.connect(
+        { ...MAINNET, namespace: 'eip155', id: 'eip155:1' },
+        { uuid: 'tronlink' }
+      )
+    ).rejects.toThrow(/expected a 'tron' network/)
+  })
+
+  it('throws when the wallet is not installed', async () => {
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(c.connect(MAINNET, { uuid: 'tronlink' })).rejects.toThrow(
+      /not installed/
+    )
+  })
+
+  it('translates a wallet "user rejected" into type:rejected', async () => {
+    const provider = makeProvider('TtronlinkAddr')
+    provider.request.mockRejectedValueOnce(
+      new Error('user rejected the request')
+    )
+    install('tronlink', provider)
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(
+      c.connect(MAINNET, { uuid: 'tronlink' })
+    ).rejects.toMatchObject({ type: 'rejected' })
+  })
+
+  it('throws when the wallet exposes no address after the request', async () => {
+    install('tronlink', makeProvider(null))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(c.connect(MAINNET, { uuid: 'tronlink' })).rejects.toThrow(
+      /no address/
+    )
+  })
+})
+
+describe('sendTransaction', () => {
+  it('builds a native transfer via REST, signs via the wallet, and broadcasts', async () => {
+    const provider = makeProvider('TFrom')
+    install('tronlink', provider)
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+
+    enqueue(
+      {
+        txID: 'native1',
+        raw_data: nativeRawData('TFrom', 'TTo', 1_000_000),
+        visible: true
+      },
+      { result: true, txid: 'native1' }
+    )
+    const txid = await c.sendTransaction({
+      from: 'TFrom',
+      to: 'TTo',
+      amount: 1_000_000
+    })
+    expect(txid).toBe('native1')
+    expect(provider.tronWeb.trx.sign).toHaveBeenCalledOnce()
+    // The signed (not unsigned) tx is what gets broadcast.
+    const broadcastBody = JSON.parse(
+      (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[1][1].body
+    )
+    expect(broadcastBody.signature).toEqual(['SIG'])
+  })
+
+  it('builds a TRC20 transfer via triggersmartcontract', async () => {
+    const provider = makeProvider('TFrom')
+    install('tronlink', provider)
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+
+    enqueue(
+      {
+        result: { result: true },
+        transaction: {
+          txID: 'trc1',
+          raw_data: trc20RawData(
+            'TFrom',
+            'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+            'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+            5_000_000
+          )
+        }
+      },
+      { result: true, txid: 'trc1' }
+    )
+    const txid = await c.sendTransaction({
+      from: 'TFrom',
+      to: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+      amount: 5_000_000,
+      contractAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+    })
+    expect(txid).toBe('trc1')
+    const triggerBody = JSON.parse(
+      (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0][1].body
+    )
+    expect(triggerBody.function_selector).toBe('transfer(address,uint256)')
+  })
+
+  it('rejects a built tx whose recipient does not match the request (MITM guard)', async () => {
+    const provider = makeProvider('TFrom')
+    install('tronlink', provider)
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    // Endpoint returns a tx paying a DIFFERENT recipient than requested.
+    enqueue({
+      txID: 'evil',
+      raw_data: nativeRawData('TFrom', 'TEvil', 1_000_000)
+    })
+    await expect(
+      c.sendTransaction({ from: 'TFrom', to: 'TTo', amount: 1_000_000 })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+    expect(provider.tronWeb.trx.sign).not.toHaveBeenCalled()
+  })
+
+  it('rejects when `from` does not match the connected address', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    await expect(
+      c.sendTransaction({ from: 'TSomeoneElse', to: 'TTo', amount: 1 })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('throws when no wallet is connected', async () => {
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(
+      c.sendTransaction({ from: 'a', to: 'b', amount: 1 })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('translates a sign rejection into type:rejected', async () => {
+    const provider = makeProvider('TFrom')
+    provider.tronWeb.trx.sign.mockRejectedValueOnce(
+      new Error('Confirmation declined by user')
+    )
+    install('tronlink', provider)
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    enqueue({ txID: 'x', raw_data: nativeRawData('TFrom', 'TTo', 1) })
+    await expect(
+      c.sendTransaction({ from: 'TFrom', to: 'TTo', amount: 1 })
+    ).rejects.toMatchObject({ type: 'rejected' })
+  })
+})
+
+describe('signMessage', () => {
+  it('proxies to the wallet tronWeb.trx.signMessageV2', async () => {
+    const provider = makeProvider('TFrom')
+    install('tronlink', provider)
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    expect(await c.signMessage('hello')).toEqual({
+      type: 'standard',
+      signature: '0xsignature'
+    })
+    expect(provider.tronWeb.trx.signMessageV2).toHaveBeenCalledWith('hello')
+  })
+
+  it('throws when no wallet is connected', async () => {
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(c.signMessage('hi')).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+})
+
+describe('disconnect + state', () => {
+  it('clears the active wallet and emits state transitions', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    const states: string[] = []
+    c.subscribe(s => states.push(s.status))
+
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    await c.disconnect()
+
+    expect(states).toEqual(['connecting', 'connected', 'disconnected'])
+    await expect(c.signMessage('x')).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+})
+
+describe('wallet events', () => {
+  it('updates the active address on accountsChanged with a string[] payload', async () => {
+    const provider = makeProvider('TFrom')
+    install('okx', provider)
+    const c = new TronConnector(fastConfig(['okx']))
+    const seen: Array<string | undefined> = []
+    c.subscribe(s => seen.push(s.address))
+    await c.connect(MAINNET, { uuid: 'okx' })
+
+    provider.emit('accountsChanged', ['TSwitched'])
+    expect(seen[seen.length - 1]).toBe('TSwitched')
+  })
+
+  it('treats accountsChanged([]) as a disconnect', async () => {
+    const provider = makeProvider('TFrom')
+    install('okx', provider)
+    const c = new TronConnector(fastConfig(['okx']))
+    const states: string[] = []
+    c.subscribe(s => states.push(s.status))
+    await c.connect(MAINNET, { uuid: 'okx' })
+
+    provider.emit('accountsChanged', [])
+    expect(states[states.length - 1]).toBe('disconnected')
+    await expect(c.signMessage('x')).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+
+  it('cleans up listeners on disconnect (no events after teardown)', async () => {
+    const provider = makeProvider('TFrom')
+    install('tronlink', provider)
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    await c.disconnect()
+
+    expect(provider.removeListener).toHaveBeenCalled()
+    const states: string[] = []
+    c.subscribe(s => states.push(s.status))
+    // Firing after teardown must not resurrect state.
+    provider.emit('accountsChanged', ['TGhost'])
+    expect(states).toEqual([])
+  })
+})
+
+describe('sendTransaction — wallet dropped tronWeb post-connect', () => {
+  it('throws a clear WalletConnectorError instead of a raw TypeError', async () => {
+    const provider = makeProvider('TFrom')
+    install('tronlink', provider)
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    enqueue({ txID: 'x', raw_data: nativeRawData('TFrom', 'TTo', 1) })
+    ;(provider as { tronWeb?: unknown }).tronWeb = undefined
+
+    await expect(
+      c.sendTransaction({ from: 'TFrom', to: 'TTo', amount: 1 })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+})
+
+describe('sendTransaction — input validation', () => {
+  it('rejects a non-integer amount before building (no raw RangeError)', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    await expect(
+      c.sendTransaction({ from: 'TFrom', to: 'TTo', amount: 1.5 })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('rejects an amount beyond the safe-integer range (silent precision loss)', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    await expect(
+      c.sendTransaction({
+        from: 'TFrom',
+        to: 'TTo',
+        amount: Number.MAX_SAFE_INTEGER + 2
+      })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('rejects a TRC20 recipient whose base58 checksum is invalid', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    await expect(
+      c.sendTransaction({
+        from: 'TFrom',
+        to: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6u', // corrupted checksum
+        amount: 1_000_000,
+        contractAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+      })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+})
+
+describe('connect failure does not leave a stale active connection', () => {
+  it('clears the prior connection when a reconnect fails', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    const okx = makeProvider('TOkx')
+    okx.request.mockRejectedValueOnce(new Error('user rejected the request'))
+    install('okx', okx)
+    const c = new TronConnector(fastConfig(['tronlink', 'okx']))
+
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    await expect(c.connect(MAINNET, { uuid: 'okx' })).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+
+    // active must be cleared (not still pointing at tronlink).
+    await expect(c.signMessage('x')).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+
+  it('clears the prior connection when a reconnect targets a not-installed wallet', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    // okx enabled but not installed → detectProvider returns undefined.
+    const c = new TronConnector(fastConfig(['tronlink', 'okx']))
+
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    await expect(c.connect(MAINNET, { uuid: 'okx' })).rejects.toThrow(
+      /not installed/
+    )
+
+    await expect(c.signMessage('x')).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+})
+
+describe('wrapper prefers a ready provider over a non-ready stub', () => {
+  it('detects Trust when trustWallet is a non-ready stub but trustwallet is ready', async () => {
+    const w = window as unknown as Record<string, unknown>
+    w['trustWallet'] = { tronLink: {} } // present but no tronWeb → not ready
+    w['trustwallet'] = { tronLink: makeProvider('TtrustAddr') }
+    const c = new TronConnector(fastConfig(['trust']))
+    expect((await c.getAvailableWallets('tron')).map(r => r.uuid)).toEqual([
+      'trust'
+    ])
+  })
+})
+
+describe('switchNetwork', () => {
+  it('repoints the node endpoint and returns the current address', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    const result = await c.switchNetwork(SHASTA)
+    expect(result.networkId).toBe('tron:0x94a9059e')
+    expect(result.address).toBe('TFrom')
+
+    // A subsequent send should hit the Shasta endpoint.
+    enqueue(
+      { txID: 's1', raw_data: nativeRawData('TFrom', 'TTo', 1) },
+      { result: true, txid: 's1' }
+    )
+    await c.sendTransaction({ from: 'TFrom', to: 'TTo', amount: 1 })
+    const url = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+    expect(url).toContain('shasta')
+  })
+
+  it('throws when called before connect', async () => {
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await expect(c.switchNetwork(MAINNET)).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+
+  it('wraps a missing-endpoint failure as WalletConnectorError', async () => {
+    install('tronlink', makeProvider('TFrom'))
+    const c = new TronConnector(fastConfig(['tronlink']))
+    await c.connect(MAINNET, { uuid: 'tronlink' })
+    // A Tron network with no default/configured endpoint → getClient throws a
+    // raw Error; switchNetwork must surface it as a WalletConnectorError.
+    const unknownTron = makeNetwork(
+      'tron:0xdeadbeef' as Network['id'],
+      'Unknown Tron'
+    )
+    await expect(c.switchNetwork(unknownTron)).rejects.toBeInstanceOf(
+      WalletConnectorError
+    )
+  })
+})