tapimo 0.15.1 → 0.18.1

package/src/internal/routes/providers/legacyMeshOutbound.test.ts

@@ -0,0 +1,401 @@
+import { AbiFunction, AbiParameters, Hex } from 'ox'
+import { encodeAbiParameters, keccak256, parseAbiParameters, stringToHex } from 'viem'
+import { describe, expect, test } from 'vitest'
+
+import * as TestRoutes from '../../../../test/Routes.js'
+import * as Tron from '../../Tron.js'
+import * as Provider from '../Provider.js'
+import * as LegacyMesh from './legacyMesh.js'
+import * as Outbound from './legacyMeshOutbound.js'
+import * as Delivery from './legacyMeshOutboundDelivery.js'
+
+const amount = 10_000_000n
+const minimum = 9_900_000n
+const fee = 1_000n
+const sourceToken = '0x20C00000000000000000000014f22CA97301EB73'
+const sourceOft = '0xaf37E8B6C9ED7f6318979f56Fc287d76c30847ff'
+const feeWrapper = '0x0cEb237E109eE22374a567c6b09F373C73FA4cBb'
+const pathUsd = '0x20c0000000000000000000000000000000000000'
+const composer = '0x759BA420bF1ded1765F18C2DC3Fc57A1964A2Ad1'
+const adapter = '0x77652D5aba086137b595875263FC200182919B92'
+const pool = 'TFG4wBaDQ8sHWWP1ACeSGnoNR6RRzevLPt'
+const token = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+const sender = '0x2222222222222222222222222222222222222222'
+const recipient = Tron.fromEvmAddress('0x1111111111111111111111111111111111111111')
+const guid = `0x${'33'.repeat(32)}` as const
+const onwardGuid = `0x${'44'.repeat(32)}` as const
+const hash = `${'55'.repeat(32)}`
+const approve = AbiFunction.from('function approve(address spender,uint256 amount) returns (bool)')
+const wrap = AbiFunction.from('function wrap(address token,address to,uint256 amount)')
+const send = AbiFunction.from(
+  'function send((uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, (uint256 nativeFee, uint256 lzTokenFee) fee, address refundAddress) payable',
+)
+const sendParam = AbiParameters.from(
+  '(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)',
+)
+
+const candidate = Provider.getQuoteCandidates({
+  catalog: TestRoutes.snapshot,
+  destinationChain: 'tron',
+  destinationToken: 'USDT',
+  providers: [LegacyMesh.legacyMesh()],
+  sourceAmount: amount.toString(),
+  sourceAmountUnits: 'baseUnits',
+  sourceChain: 'tempo',
+  sourceToken: 'USDT0',
+})[0]!
+
+describe('validateTransferAction', () => {
+  test('accepts exact approvals, wrapped fee, and the composed Tron recipient', () => {
+    expect(
+      Outbound.validateTransferAction({
+        action: action(),
+        candidate,
+        destinationAmountMin: minimum.toString(),
+        method: 'transaction',
+        mode: 'exactSource',
+        recipient,
+        sender,
+      }),
+    ).toEqual({
+      tokenApprovals: [
+        { amount: fee.toString(), spender: feeWrapper, token: pathUsd },
+        { amount: fee.toString(), spender: sourceOft, token: feeWrapper },
+      ],
+    })
+  })
+
+  test('rejects a changed recipient, fee, or payment approval', () => {
+    const changed = [
+      {
+        ...action(),
+        calls: action().calls.map((call, index) =>
+          index === 1
+            ? { ...call, data: AbiFunction.encodeData(approve, [feeWrapper, fee + 1n]) }
+            : call,
+        ),
+      },
+      {
+        ...action(),
+        calls: action().calls.map((call, index) =>
+          index === 4
+            ? {
+                ...call,
+                data: AbiFunction.encodeData(send, [
+                  first(Tron.fromEvmAddress('0x3333333333333333333333333333333333333333')),
+                  { nativeFee: fee, lzTokenFee: 0n },
+                  sender,
+                ]),
+              }
+            : call,
+        ),
+      },
+      {
+        ...action(),
+        calls: action().calls.map((call, index) =>
+          index === 4
+            ? {
+                ...call,
+                data: AbiFunction.encodeData(send, [
+                  first(recipient),
+                  { nativeFee: fee + 1n, lzTokenFee: 0n },
+                  sender,
+                ]),
+              }
+            : call,
+        ),
+      },
+    ]
+    for (const value of changed)
+      expect(() =>
+        Outbound.validateTransferAction({
+          action: value,
+          candidate,
+          destinationAmountMin: minimum.toString(),
+          method: 'transaction',
+          mode: 'exactSource',
+          recipient,
+          sender,
+        }),
+      ).toThrowError(Provider.ProviderPayloadError)
+  })
+})
+
+describe('verifyForwarding', () => {
+  test('binds the composer GUID to its distinct Tron packet and actual amount', () => {
+    expect(
+      Delivery.verifyForwarding({
+        guid,
+        logs: forwardingLogs(),
+        minimum,
+        recipient: Tron.toEvmAddress(recipient),
+        sourceAmount: amount,
+      }),
+    ).toEqual({ amount: amount - 10_000n, guid: onwardGuid, type: 'found' })
+  })
+
+  test('rejects a packet addressed to another Tron account', () => {
+    expect(
+      Delivery.verifyForwarding({
+        guid,
+        logs: forwardingLogs(
+          Tron.toEvmAddress(Tron.fromEvmAddress('0x3333333333333333333333333333333333333333')),
+        ),
+        minimum,
+        recipient: Tron.toEvmAddress(recipient),
+        sourceAmount: amount,
+      }).type,
+    ).toBe('invalid')
+  })
+
+  test('classifies a native OFT refund as requiring recovery', () => {
+    const logs = forwardingLogs().map((log, index) =>
+      index === 2
+        ? {
+            ...log,
+            topics: [
+              keccak256(stringToHex('Refunded(bytes32,address)')),
+              guid,
+              Hex.padLeft('0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92', 32),
+            ] as [Hex.Hex, ...Hex.Hex[]],
+          }
+        : log,
+    )
+    expect(
+      Delivery.verifyComposerOutcome({
+        guid,
+        logs,
+        minimum,
+        recipient: Tron.toEvmAddress(recipient),
+        sourceAmount: amount,
+      }).type,
+    ).toBe('action-required')
+  })
+})
+
+describe('verifyTronReceipt', () => {
+  test('returns the exact solidified USDT amount', () => {
+    expect(
+      Delivery.verifyTronReceipt({
+        amount: amount - 10_000n,
+        guid: onwardGuid,
+        recipient: Tron.toEvmAddress(recipient),
+        receipt: tronReceipt(),
+        transactionHash: hash,
+      }),
+    ).toEqual({
+      destinationAmount: (amount - 10_000n).toString(),
+      transactionHash: `0x${hash}`,
+      type: 'verified',
+    })
+  })
+
+  test('keeps unrelated GUIDs pending and rejects altered beneficiary evidence', () => {
+    expect(
+      Delivery.verifyTronReceipt({
+        amount: amount - 10_000n,
+        guid,
+        recipient: Tron.toEvmAddress(recipient),
+        receipt: tronReceipt(),
+        transactionHash: hash,
+      }).type,
+    ).toBe('pending')
+    expect(
+      Delivery.verifyTronReceipt({
+        amount: amount - 10_000n,
+        guid: onwardGuid,
+        recipient: Tron.toEvmAddress(
+          Tron.fromEvmAddress('0x3333333333333333333333333333333333333333'),
+        ),
+        receipt: tronReceipt(),
+        transactionHash: hash,
+      }).type,
+    ).toBe('invalid')
+  })
+})
+
+describe('selectEventCandidates', () => {
+  test('bounds receipt reads and resumes at the first unprocessed candidate', () => {
+    const page = {
+      data: Array.from({ length: 26 }, (_, index) => ({
+        block_number: index === 0 ? 0 : 1,
+        result: { guid: index === 1 ? guid : onwardGuid },
+        transaction_id: index.toString(16).padStart(64, '0'),
+      })),
+      success: true,
+    }
+    const first = Delivery.selectEventCandidates({
+      budget: 20,
+      firstBlock: 1,
+      guid: onwardGuid,
+      headNumber: 1,
+      offset: 0,
+      page,
+    })
+    const second = Delivery.selectEventCandidates({
+      budget: 20,
+      firstBlock: 1,
+      guid: onwardGuid,
+      headNumber: 1,
+      offset: first.offset,
+      page,
+    })
+    expect([first.events.length, first.offset, second.events.length, second.offset]).toEqual([
+      20, 22, 4, 26,
+    ])
+    expect([...first.events, ...second.events].map((event) => event.transaction_id)).toEqual(
+      page.data.slice(2).map((event) => event.transaction_id),
+    )
+  })
+
+  test('retains an unindexed GUID candidate when the receipt budget is exhausted', () => {
+    const page = {
+      data: [{ block_number: 1, transaction_id: hash }],
+      success: true,
+    }
+    expect(
+      Delivery.selectEventCandidates({
+        budget: 0,
+        firstBlock: 1,
+        guid: onwardGuid,
+        headNumber: 1,
+        offset: 0,
+        page,
+      }),
+    ).toEqual({ events: [], offset: 0 })
+  })
+})
+
+function first(to: string) {
+  return {
+    amountLD: amount,
+    composeMsg: AbiParameters.encode(sendParam, [
+      {
+        amountLD: amount,
+        composeMsg: '0x',
+        dstEid: 30_420,
+        extraOptions: '0x',
+        minAmountLD: minimum,
+        oftCmd: '0x' as const,
+        to: Hex.padLeft(Tron.toEvmAddress(to), 32),
+      },
+    ]),
+    dstEid: 30_110,
+    extraOptions: Hex.concat(
+      '0x0003010023030000',
+      Hex.fromNumber(500_000n, { size: 16 }),
+      Hex.fromNumber(1n, { size: 16 }),
+    ),
+    minAmountLD: minimum,
+    oftCmd: '0x' as const,
+    to: Hex.padLeft(composer, 32),
+  }
+}
+
+function action() {
+  return {
+    calls: [
+      { data: AbiFunction.encodeData(approve, [sourceOft, amount]), to: sourceToken, value: '0x0' },
+      { data: AbiFunction.encodeData(approve, [feeWrapper, fee]), to: pathUsd, value: '0x0' },
+      { data: AbiFunction.encodeData(wrap, [pathUsd, sender, fee]), to: feeWrapper, value: '0x0' },
+      { data: AbiFunction.encodeData(approve, [sourceOft, fee]), to: feeWrapper, value: '0x0' },
+      {
+        data: AbiFunction.encodeData(send, [
+          first(recipient),
+          { nativeFee: fee, lzTokenFee: 0n },
+          sender,
+        ]),
+        to: sourceOft,
+        value: '0x0',
+      },
+    ],
+    type: 'evm:calls' as const,
+  }
+}
+
+function forwardingLogs(
+  recipientEvm = Tron.toEvmAddress(recipient),
+): Delivery.verifyForwarding.Options['logs'] {
+  const packet = Hex.concat(
+    Hex.fromNumber(1, { size: 1 }),
+    Hex.fromNumber(1, { size: 8 }),
+    Hex.fromNumber(30_110, { size: 4 }),
+    Hex.padLeft(adapter, 32),
+    Hex.fromNumber(30_420, { size: 4 }),
+    Hex.padLeft(Tron.toEvmAddress(pool), 32),
+    onwardGuid,
+    Hex.padLeft(recipientEvm, 32),
+    Hex.fromNumber(amount - 10_000n, { size: 8 }),
+  )
+  const base = {
+    blockHash: guid,
+    blockNumber: 1n,
+    removed: false,
+    transactionHash: guid,
+    transactionIndex: 0,
+  } as const
+  return [
+    {
+      ...base,
+      address: '0x1a44076050125825900e736c501f859c50fE728c',
+      data: encodeAbiParameters(parseAbiParameters('bytes,bytes,address'), [packet, '0x', adapter]),
+      logIndex: 0,
+      topics: [keccak256(stringToHex('PacketSent(bytes,bytes,address)'))],
+    },
+    {
+      ...base,
+      address: adapter,
+      data: encodeAbiParameters(parseAbiParameters('uint32,uint256,uint256'), [
+        30_420,
+        amount,
+        amount - 10_000n,
+      ]),
+      logIndex: 1,
+      topics: [
+        keccak256(stringToHex('OFTSent(bytes32,uint32,address,uint256,uint256)')),
+        onwardGuid,
+        Hex.padLeft(composer, 32),
+      ],
+    },
+    {
+      ...base,
+      address: composer,
+      data: '0x',
+      logIndex: 2,
+      topics: [keccak256(stringToHex('Sent(bytes32,address)')), guid, Hex.padLeft(adapter, 32)],
+    },
+  ]
+}
+
+function tronReceipt() {
+  const recipientEvm = Tron.toEvmAddress(recipient)
+  const event = {
+    address: Tron.toEvmAddress(pool).slice(2),
+    data: encodeAbiParameters(parseAbiParameters('uint32,uint256'), [
+      30_110,
+      amount - 10_000n,
+    ]).slice(2),
+    topics: [
+      keccak256(stringToHex('OFTReceived(bytes32,uint32,address,uint256)')).slice(2),
+      onwardGuid.slice(2),
+      Hex.padLeft(recipientEvm, 32).slice(2),
+    ],
+  }
+  const transfer = {
+    address: Tron.toEvmAddress(token).slice(2),
+    data: Hex.fromNumber(amount - 10_000n, { size: 32 }).slice(2),
+    topics: [
+      keccak256(stringToHex('Transfer(address,address,uint256)')).slice(2),
+      Hex.padLeft(Tron.toEvmAddress(pool), 32).slice(2),
+      Hex.padLeft(recipientEvm, 32).slice(2),
+    ],
+  }
+  return {
+    blockNumber: 1,
+    blockTimeStamp: 1,
+    id: hash,
+    log: [event, transfer],
+    receipt: { result: 'SUCCESS' },
+    result: 'SUCCESS',
+  }
+}