tapimo 0.15.1 → 0.18.1

package/src/internal/routes/Transfer.tron.test.ts

@@ -0,0 +1,172 @@
+import { AbiFunction, Address, Hash, Secp256k1, Signature } from 'ox'
+
+import * as TestApp from '../../../test/App.js'
+import * as TestRoutes from '../../../test/Routes.js'
+import * as RoutesTransfers from '../../db/tables/routesTransfers.js'
+import * as Tron from '../Tron.js'
+import * as Transfer from './Transfer.js'
+import * as TronTransferSubsidy from './TronTransferSubsidy.js'
+
+const db = TestApp.database()
+const now = new Date('2026-01-01T00:00:00.000Z')
+const token = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+const recipient = Tron.fromEvmAddress('0x1111111111111111111111111111111111111111')
+const transferCall = AbiFunction.from(
+  'function transfer(address to, uint256 amount) returns (bool)',
+)
+
+beforeEach(() => vi.useFakeTimers({ now, toFake: ['Date'] }))
+afterEach(() => vi.useRealTimers())
+
+function prepared(account: string): TronTransferSubsidy.Prepared {
+  const data = AbiFunction.encodeData(transferCall, [Tron.toEvmAddress(recipient), 3_001n]).slice(2)
+  const rawDataHex = '010203'
+  const hash = Hash.sha256(`0x${rawDataHex}`)
+  const raw_data = {
+    contract: [
+      {
+        contract_address: `41${Tron.toEvmAddress(token).slice(2)}`,
+        data,
+        owner_address: `41${Tron.toEvmAddress(account).slice(2)}`,
+        type: 'TriggerSmartContract' as const,
+      },
+    ] as const,
+    expiration: now.getTime() + 60_000,
+    fee_limit: 100_000_000,
+    ref_block_bytes: 'a2b4',
+    ref_block_hash: '1234567890abcdef',
+    timestamp: now.getTime(),
+  }
+  return {
+    account,
+    amount: '3001',
+    chainId: 'tron:0x2b6653dc',
+    expiresAt: raw_data.expiration,
+    hash,
+    nativeAmount: '100000000',
+    rawDataHex,
+    request: { network: 'tron:mainnet', transaction: { raw_data } },
+    transaction: { raw_data, raw_data_hex: rawDataHex, txID: hash.slice(2) },
+  }
+}
+
+describe('prepareTronSubsidy', () => {
+  test('persists unsigned terms before signing, replays them, and shares one signed source settlement', async () => {
+    const { privateKey, publicKey } = Secp256k1.createKeyPair()
+    const account = Tron.fromEvmAddress(Address.fromPublicKey(publicKey))
+    const fixture = prepared(account)
+    const signed: TronTransferSubsidy.Signed = {
+      ...fixture,
+      signature: Signature.toHex(Secp256k1.sign({ payload: fixture.hash, privateKey })).slice(2),
+    }
+    const amount = { baseUnits: '3001', currency: 'USD', decimals: 6, formatted: '0.003001' }
+    const snapshot = TestRoutes.transferSnapshot({
+      destinationChain: {
+        addressFormat: 'base58check',
+        id: 'tron:0x2b6653dc',
+        kind: 'tron',
+        name: 'Tron',
+      },
+      destinationToken: {
+        address: token,
+        currency: 'USD',
+        decimals: 6,
+        name: 'Tether USD',
+        standard: 'TRC-20',
+        symbol: 'USDT',
+        tokenKey: `tron:0x2b6653dc/trc20:${token}`,
+        verified: true,
+      },
+      recipient,
+      sourceChain: { addressFormat: 'hex', id: 'eip155:4217', kind: 'evm', name: 'Tempo' },
+    })
+    const subsidyCommitment = {
+      account,
+      amount,
+      chainId: snapshot.destinationChain.id,
+      nativeAmount: '100000000',
+      tokenAddress: token,
+    }
+    const sourceHash = `0x${'ab'.repeat(32)}`
+    const records = []
+    for (const orgId of ['org_tron_first', 'org_tron_second']) {
+      const record = await Transfer.create(db, {
+        apiKeyId: 'key_test',
+        environment: 'production',
+        orgId,
+        snapshot,
+        subsidyCommitment,
+      })
+      records.push(record)
+      expect(
+        (
+          await Transfer.registerSourceTransactions(db, {
+            chainId: snapshot.sourceChain.id,
+            id: record.id,
+            providerState: {},
+            transactionHashes: [sourceHash],
+          })
+        ).type,
+      ).toBe('registered')
+    }
+    const first = await Transfer.prepareTronSubsidy(db, {
+      account,
+      chainId: snapshot.destinationChain.id,
+      id: records[0]!.id,
+      orgId: records[0]!.orgId,
+      prepare: async () => fixture,
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(first.type).toBe('prepared')
+    if (first.type !== 'prepared') throw new Error('Expected persisted Tron preparation.')
+    expect(
+      TronTransferSubsidy.readPrepared(first.record.providerState?.['tronTransferSubsidyPrepared']),
+    ).toEqual(fixture)
+    const replay = await Transfer.prepareTronSubsidy(db, {
+      account,
+      chainId: snapshot.destinationChain.id,
+      id: records[0]!.id,
+      orgId: records[0]!.orgId,
+      prepare: async () => {
+        throw new Error('Prepared Tron request was replaced.')
+      },
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(replay.type).toBe('prepared')
+    if (replay.type !== 'prepared') throw new Error('Expected persisted Tron preparation.')
+    expect(replay.prepared).toEqual(fixture)
+    const persisted = await Transfer.signTronSubsidy(db, { id: records[0]!.id, signed })
+    expect(persisted.type).toBe('signed')
+    const shared = await Transfer.prepareTronSubsidy(db, {
+      account,
+      chainId: snapshot.destinationChain.id,
+      id: records[1]!.id,
+      orgId: records[1]!.orgId,
+      prepare: async () => {
+        throw new Error('Shared source produced a second subsidy.')
+      },
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(shared.type).toBe('shared')
+    if (shared.type !== 'shared') throw new Error('Expected a shared Tron settlement.')
+    expect(shared.record.subsidyAmount).toBeNull()
+    expect(shared.record.subsidyTransactionHash).toBe(signed.hash)
+    for (const record of records)
+      expect(
+        (
+          await Transfer.complete(db, {
+            chainId: snapshot.destinationChain.id,
+            destinationAmount: snapshot.destinationAmount!,
+            id: record.id,
+            transactionHashes: [`0x${'cd'.repeat(32)}`, signed.hash],
+          })
+        ).type,
+      ).toBe('completed')
+    expect((await RoutesTransfers.listUnreportedSubsidies(db)).map(({ id }) => id)).toEqual([
+      records[0]!.id,
+    ])
+  })
+})