tapimo 0.13.0 → 0.14.0

package/src/internal/funding/providers/stargate.test.ts

@@ -1,11 +1,17 @@
 import { AbiFunction, Hex } from 'ox'
+import { base } from 'viem/chains'
+import { tempoMainnet } from 'viem/tempo/chains'
+
+import * as Anvil from '../../../../test/Anvil.js'
 
 import type * as Action from '../Action.js'
 import type * as Catalog from '../Catalog.js'
+import * as FundingChain from '../Chain.js'
 import * as FundingProvider from '../Provider.js'
 import * as Stargate from './stargate.js'
 
 const amount = 1_000_000n
+const destinationPool = '0x8c76e2f6c5ceda9aa7772e7eff30280226c44392'
 const destinationToken = '0x20C000000000000000000000b9537d11c60E8b50'
 const nativeFee = 10_000n
 const otherAddress = '0x9999999999999999999999999999999999999999'
@@ -13,6 +19,11 @@ const pool = '0x27a16dc786820B16E5c9028b75B99F6f604b5d26'
 const recipient = '0x1111111111111111111111111111111111111111'
 const sender = '0x2222222222222222222222222222222222222222'
 const sourceToken = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
+const sourceTransactionHash = '0xfd71359adf5095f2ab512a19e0a2df6c8cc0db14ac8a52286d61287daabdccd4'
+const validAfter = '2020-01-01T00:00:00.000Z'
+const destinationTransactionHash =
+  '0x3dfaba0a78b8f4bc09e55e05211c8120729e7b6879efe32613883befbca666da'
+const guid = '0x5549d117c8b23f0ecdf05c2604ed989cf0034f378707bd81319e93834f2f85f2'
 
 const approve = AbiFunction.from('function approve(address spender, uint256 amount)')
 const sendToken = AbiFunction.from(
@@ -26,6 +37,7 @@ describe('stargate', () => {
       id: 'stargate',
       name: 'Stargate',
       prepareTransfer: expect.any(Function),
+      verifySourceTransaction: expect.any(Function),
     })
   })
 })
@@ -82,9 +94,158 @@ describe('validateAction', () => {
         sourceTokenAddress: sourceToken,
       }),
     ).toThrowError(FundingProvider.ProviderPayloadError)
-    expect(() => validate(action(), { configuration: { poolAddress: otherAddress } })).toThrowError(
-      FundingProvider.ProviderPayloadError,
-    )
+    expect(() =>
+      validate(action(), {
+        configuration: {
+          destinationPoolAddress: destinationPool,
+          poolAddress: otherAddress,
+          sourceEid: 30_184,
+        },
+      }),
+    ).toThrowError(FundingProvider.ProviderPayloadError)
+  })
+})
+
+describe.skipIf(!Anvil.available)('source and destination evidence', () => {
+  const bridgedAmount = '200000'
+  const bridgedRecipient = '0x7212623e4cff9ad010d28aa065fad2bf58578783'
+  const bridgedSender = '0x52b650a62e384f68880d0a1dc2b84dfed47d5660'
+  const configuration = {
+    destinationPoolAddress: destinationPool,
+    poolAddress: pool,
+    sourceEid: 30_184,
+  }
+  let destinationChain: FundingChain.Chain
+  let destination: Anvil.start.ReturnType
+  let sourceChain: FundingChain.Chain
+  let source: Anvil.start.ReturnType
+
+  beforeAll(async () => {
+    ;[destination, source] = await Promise.all([
+      Anvil.start({ chain: tempoMainnet, forkUrl: tempoMainnet.rpcUrls.default.http[0]! }),
+      Anvil.start({ chain: base, forkUrl: base.rpcUrls.default.http[0]! }),
+    ])
+    destinationChain = FundingChain.from({
+      id: 'eip155:4217',
+      name: 'Tempo',
+      rpcUrls: [destination.rpcUrl],
+      slug: 'tempo',
+    })
+    sourceChain = FundingChain.from({
+      id: 'eip155:8453',
+      name: 'Base',
+      rpcUrls: [source.rpcUrl],
+      slug: 'base',
+    })
+  })
+
+  afterAll(async () => {
+    await Promise.all([destination?.stop(), source?.stop()])
+  })
+
+  test('verifies a direct Base Stargate send and its LayerZero GUID', async () => {
+    const receipt = await source.client.getTransactionReceipt({ hash: sourceTransactionHash })
+    await expect(
+      Stargate.verifySourceTransaction({
+        configuration,
+        destinationTokenAddress: destinationToken,
+        recipient: bridgedRecipient,
+        sender: bridgedSender,
+        sourceAmount: bridgedAmount,
+        sourceChain,
+        sourceTokenAddress: sourceToken,
+        transactionHash: sourceTransactionHash,
+        validAfter,
+      }),
+    ).resolves.toEqual({
+      guid,
+      sourceBlock: { hash: receipt.blockHash, number: receipt.blockNumber },
+      sourceEid: 30_184,
+      type: 'verified',
+    })
+  })
+
+  test('keeps missing transactions pending and rejects mismatched terms', async () => {
+    const options = {
+      configuration,
+      destinationTokenAddress: destinationToken,
+      recipient: bridgedRecipient,
+      sender: bridgedSender,
+      sourceAmount: bridgedAmount,
+      sourceChain,
+      sourceTokenAddress: sourceToken,
+      transactionHash: sourceTransactionHash,
+      validAfter,
+    }
+    await expect(
+      Stargate.verifySourceTransaction({
+        ...options,
+        transactionHash: `0x${'99'.repeat(32)}`,
+      }),
+    ).resolves.toEqual({ type: 'pending' })
+    await expect(
+      Stargate.verifySourceTransaction({ ...options, recipient: otherAddress }),
+    ).resolves.toEqual({ type: 'invalid' })
+    await expect(
+      Stargate.verifySourceTransaction({ ...options, validAfter: '2099-01-01T00:00:00.000Z' }),
+    ).resolves.toEqual({ type: 'invalid' })
+  })
+
+  test('rejects reverted and malformed source transactions', async () => {
+    const account = Anvil.getAccount(1)
+    const reverted = await source.client.sendTransactionSync({
+      account,
+      data: '0xdeadbeef',
+      gas: 100_000n,
+      to: pool,
+    })
+    const malformed = await source.client.sendTransactionSync({
+      account,
+      data: '0xdeadbeef',
+      gas: 100_000n,
+      to: account.address,
+    })
+    const options = {
+      configuration,
+      destinationTokenAddress: destinationToken,
+      recipient: bridgedRecipient,
+      sender: account.address,
+      sourceAmount: bridgedAmount,
+      sourceChain,
+      sourceTokenAddress: sourceToken,
+      validAfter,
+    }
+    await expect(
+      Stargate.verifySourceTransaction({
+        ...options,
+        transactionHash: reverted.transactionHash,
+      }),
+    ).resolves.toEqual({ type: 'invalid' })
+    await expect(
+      Stargate.verifySourceTransaction({
+        ...options,
+        transactionHash: malformed.transactionHash,
+      }),
+    ).resolves.toEqual({ type: 'invalid' })
+  })
+
+  test('discovers and verifies the exact Tempo USDC.e delivery', async () => {
+    const receipt = await destination.client.getTransactionReceipt({
+      hash: destinationTransactionHash,
+    })
+    await expect(
+      Stargate.verifyDestinationDelivery({
+        configuration,
+        destinationAmount: bridgedAmount,
+        destinationBlockNumber: receipt.blockNumber.toString(),
+        destinationChain,
+        destinationTokenAddress: destinationToken,
+        guid,
+        recipient: bridgedRecipient,
+        sourceChainId: 'eip155:8453',
+        sourceTokenAddress: sourceToken,
+      }),
+    ).resolves.toEqual({ transactionHash: destinationTransactionHash, type: 'verified' })
   })
 })
 
@@ -144,7 +305,11 @@ declare namespace action {
 function validate(candidate: Action.EvmCalls, options: validate.Options = {}) {
   return Stargate.validateAction({
     action: candidate,
-    configuration: options.configuration ?? { poolAddress: pool },
+    configuration: options.configuration ?? {
+      destinationPoolAddress: destinationPool,
+      poolAddress: pool,
+      sourceEid: 30_184,
+    },
     destinationTokenAddress: options.destinationTokenAddress ?? destinationToken,
     recipient,
     sender,