tapimo 0.14.0 → 0.15.0

package/src/internal/{funding → routes}/providers/relay.test.ts

@@ -1,10 +1,11 @@
 import { Address, Hash, Hex } from 'ox'
 
 import * as TestApp from '../../../../test/App.js'
-import * as TestFunding from '../../../../test/Funding.js'
-import * as FundingDepositRequestObservations from '../../../db/tables/fundingDepositRequestObservations.js'
+import * as TestRelay from '../../../../test/Relay.js'
+import * as TestRoutes from '../../../../test/Routes.js'
+import * as RoutesDepositRequestObservations from '../../../db/tables/routesDepositRequestObservations.js'
 import * as DepositAddress from '../DepositAddress.js'
-import * as FundingProvider from '../Provider.js'
+import * as RoutesProvider from '../Provider.js'
 import * as Relay from './relay.js'
 
 const apiKey = process.env.RELAY_API_KEY
@@ -43,7 +44,7 @@ function signedWebhook(body: string) {
 }
 
 function webhookProvider(
-  dispatch: (message: FundingProvider.Webhook.receive.Dispatchable) => Promise<void>,
+  dispatch: (message: RoutesProvider.Webhook.receive.Dispatchable) => Promise<void>,
   options: webhookProvider.Options = {},
 ) {
   return Relay.relay({
@@ -60,23 +61,23 @@ declare namespace webhookProvider {
   }
 }
 
-function candidateFor(provider: FundingProvider.Provider) {
-  const candidate = FundingProvider.getQuoteCandidates({
-    catalog: TestFunding.snapshot,
-    destinationToken: 'pathUSD',
+function candidateFor(provider: RoutesProvider.Provider) {
+  const candidate = RoutesProvider.getQuoteCandidates({
+    catalog: TestRoutes.snapshot,
+    destinationToken: 'USDC.e',
     providers: [provider],
     sourceAmount: '5000000',
     sourceAmountUnits: 'baseUnits',
     sourceChain: 'base',
     sourceToken: 'USDC',
-  }).find((entry) => entry.id === 'base-usdc-tempo-pathusd-relay')
+  }).find((entry) => entry.id === 'base-usdc-tempo-usdce-relay')
   if (!candidate) throw new Error('Expected a relay candidate.')
   return candidate
 }
 
 function prepareInput(
-  provider: FundingProvider.Provider,
-): FundingProvider.prepareTransfer.Parameters {
+  provider: RoutesProvider.Provider,
+): RoutesProvider.prepareTransfer.Parameters {
   return {
     candidate: candidateFor(provider),
     method: 'transaction',
@@ -88,10 +89,10 @@ function prepareInput(
 }
 
 function depositAddressInput(
-  provider: FundingProvider.Provider,
-): FundingProvider.createDepositAddress.Parameters {
-  const candidate = FundingProvider.getDepositAddressCandidates({
-    catalog: TestFunding.snapshot,
+  provider: RoutesProvider.Provider,
+): RoutesProvider.createDepositAddress.Parameters {
+  const candidate = RoutesProvider.getDepositAddressCandidates({
+    catalog: TestRoutes.snapshot,
     destinationChainId: 4217,
     destinationToken: '0x20c00000000000000000000014f22ca97301eb73',
     providers: [provider],
@@ -113,7 +114,7 @@ function depositAddressInput(
 // key skips. Live amounts change per quote, so assertions stay shape-level.
 describe.skipIf(!apiKey)('relay.prepareTransfer (live)', () => {
   let requestBody: Record<string, unknown>
-  let result: FundingProvider.prepareTransfer.ReturnType
+  let result: RoutesProvider.prepareTransfer.ReturnType
 
   beforeAll(async () => {
     const provider = Relay.relay({
@@ -160,7 +161,7 @@ describe.skipIf(!apiKey)('relay.prepareTransfer (live)', () => {
 
 describe.skipIf(!apiKey)('relay.createDepositAddress (live)', () => {
   let requestBody: Record<string, unknown>
-  let result: FundingProvider.createDepositAddress.ReturnType
+  let result: RoutesProvider.createDepositAddress.ReturnType
 
   beforeAll(async () => {
     const provider = Relay.relay({
@@ -235,8 +236,8 @@ describe.skipIf(!apiKey)('relay.createDepositAddress (live)', () => {
         return globalThis.fetch(input, init)
       },
     })
-    const candidate = FundingProvider.getDepositAddressCandidates({
-      catalog: TestFunding.snapshot,
+    const candidate = RoutesProvider.getDepositAddressCandidates({
+      catalog: TestRoutes.snapshot,
       destinationChainId: 4217,
       destinationToken: '0x20c00000000000000000000014f22ca97301eb73',
       providers: [provider],
@@ -387,12 +388,145 @@ describe('parseDepositAddressRequests', () => {
   test('reports the invalid provider field', () => {
     expect(() => Relay.parseDepositAddressRequests({ requests: null }))
       .toThrowErrorMatchingInlineSnapshot(`
-      [FundingProvider.ProviderPayloadError: ✖ Invalid input: expected array, received null
+      [RoutesProvider.ProviderPayloadError: ✖ Invalid input: expected array, received null
         → at requests]
     `)
   })
 })
 
+describe('relay.listDepositAddressRequests', () => {
+  test('returns the actual provider subsidy amount and token', async () => {
+    const server = await TestRelay.createServer((_request, response) => {
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify({
+          requests: [
+            {
+              createdAt: '2026-09-02T00:00:00.000Z',
+              data: {
+                feeSponsorship: {
+                  actual: {
+                    sponsorPayment: {
+                      address: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+                      amount: '23838',
+                      chainId: 8453,
+                    },
+                  },
+                },
+                outTxs: [],
+              },
+              id: 'relay-sponsored-request',
+              status: 'success',
+              updatedAt: '2026-09-02T00:00:10.000Z',
+            },
+          ],
+        }),
+      )
+    })
+
+    try {
+      const provider = Relay.relay({ apiKey: 'relay-api-key', baseUrl: server.url })
+      const candidate = candidateFor(provider)
+
+      await expect(
+        provider.listDepositAddressRequests!(
+          {
+            address: `0x${'11'.repeat(20)}`,
+            destinationToken: candidate.destinationToken,
+            sourceToken: candidate.sourceToken,
+          },
+          new AbortController().signal,
+        ),
+      ).resolves.toMatchInlineSnapshot(`
+        {
+          "requests": [
+            {
+              "createdAt": "2026-09-02T00:00:00.000Z",
+              "destinationTransactionHashes": [],
+              "id": "relay-sponsored-request",
+              "refundTransactionHashes": [],
+              "sourceTransactionHashes": [],
+              "status": "success",
+              "subsidy": {
+                "amount": {
+                  "baseUnits": "23838",
+                  "currency": "USD",
+                  "decimals": 6,
+                  "formatted": "0.023838",
+                },
+                "provider": "relay",
+                "token": {
+                  "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+                  "currency": "USD",
+                  "decimals": 6,
+                  "name": "USD Coin",
+                  "standard": "ERC-20",
+                  "symbol": "USDC",
+                  "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+                  "verified": true,
+                },
+              },
+              "updatedAt": "2026-09-02T00:00:10.000Z",
+            },
+          ],
+        }
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('omits unfinished output transaction hashes', async () => {
+    const server = await TestRelay.createServer((_request, response) => {
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify({
+          requests: [
+            {
+              createdAt: '2026-09-01T22:31:00.000Z',
+              data: {
+                outTxs: [{}, { txHash: null }, { txHash: '' }, { txHash: `0x${'aa'.repeat(32)}` }],
+              },
+              id: 'relay-in-flight-request',
+              status: 'submitted',
+              updatedAt: '2026-09-01T22:31:30.000Z',
+            },
+          ],
+        }),
+      )
+    })
+
+    try {
+      const provider = Relay.relay({ apiKey: 'relay-api-key', baseUrl: server.url })
+
+      await expect(
+        provider.listDepositAddressRequests!(
+          { address: `0x${'11'.repeat(20)}` },
+          new AbortController().signal,
+        ),
+      ).resolves.toMatchInlineSnapshot(`
+        {
+          "requests": [
+            {
+              "createdAt": "2026-09-01T22:31:00.000Z",
+              "destinationTransactionHashes": [
+                "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+              ],
+              "id": "relay-in-flight-request",
+              "refundTransactionHashes": [],
+              "sourceTransactionHashes": [],
+              "status": "submitted",
+              "updatedAt": "2026-09-01T22:31:30.000Z",
+            },
+          ],
+        }
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+})
+
 describe('relay.createDepositAddress', () => {
   test('rejects subsidized provisioning outside the configured limit', async () => {
     const provider = Relay.relay({ subsidies: { maxAmount: '1' } })
@@ -402,7 +536,7 @@ describe('relay.createDepositAddress', () => {
         { ...depositAddressInput(provider), subsidize: true },
         new AbortController().signal,
       ),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingProvider.ProviderUnavailableError]`)
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[RoutesProvider.ProviderUnavailableError]`)
   })
 })
 
@@ -414,7 +548,7 @@ describe('relay.prepareTransfer', () => {
         { ...prepareInput(provider), method: 'depositAddress' },
         new AbortController().signal,
       ),
-    ).rejects.toThrow(FundingProvider.ProviderConfigurationError)
+    ).rejects.toThrow(RoutesProvider.ProviderConfigurationError)
   })
 })
 
@@ -442,13 +576,13 @@ describe('verifyWebhook', () => {
     const valid = signedWebhook(webhookPayload())
     expect(() =>
       webhook.verify({ ...valid, body: `${valid.body} ` }),
-    ).toThrowErrorMatchingInlineSnapshot(`[Funding.Provider.Relay.WebhookSignatureError]`)
+    ).toThrowErrorMatchingInlineSnapshot(`[Routes.Provider.Relay.WebhookSignatureError]`)
     valid.headers.set(
       'x-signature-timestamp',
       String(Number(valid.headers.get('x-signature-timestamp')) - 300_001),
     )
     expect(() => webhook.verify(valid)).toThrowErrorMatchingInlineSnapshot(
-      `[Funding.Provider.Relay.WebhookSignatureError]`,
+      `[Routes.Provider.Relay.WebhookSignatureError]`,
     )
   })
 })
@@ -458,23 +592,22 @@ describe('receiveWebhook', () => {
   afterEach(() => vi.useRealTimers())
 
   test('resolves the stored address and queues a bounded hint', async () => {
-    const route = TestFunding.transferSnapshot()
+    const route = TestRoutes.transferSnapshot()
     const providerAddress = Address.checksum(`0x${'ab'.repeat(20)}`)
     const record = await DepositAddress.create(db, {
-      apiKeyId: 'key_relay_webhook',
       deliveryStrategy: 'provider',
       environment: 'production',
       now: webhookNow,
       orgId: 'org_relay_webhook',
-      providerOutputToken: TestFunding.providerOutputToken(),
-      snapshot: TestFunding.depositAddressSnapshot({
+      providerOutputToken: TestRoutes.providerOutputToken(),
+      snapshot: TestRoutes.depositAddressSnapshot({
         address: providerAddress,
         provider: { id: 'relay', name: 'Relay' },
         sourceChain: route.sourceChain,
         sourceToken: route.sourceToken,
       }),
     })
-    const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
+    const dispatched: RoutesProvider.Webhook.receive.Dispatchable[] = []
     const { webhook } = webhookProvider(async (message) => {
       dispatched.push(message)
     })
@@ -482,7 +615,7 @@ describe('receiveWebhook', () => {
     const result = await webhook.receive(
       signedWebhook(webhookPayload(Address.checksum(record.address))),
     )
-    const observation = await FundingDepositRequestObservations.get(db, {
+    const observation = await RoutesDepositRequestObservations.get(db, {
       depositAddressId: record.id,
       providerRequestId: `0x${'aa'.repeat(32)}`,
     })
@@ -500,7 +633,7 @@ describe('receiveWebhook', () => {
             "addressId": Any<String>,
             "requestId": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
             "trigger": "webhook",
-            "type": "funding:deposit-address:reconcile",
+            "type": "routes:deposit-address:reconcile",
             "webhookTiming": {
               "enqueuedAt": "2027-01-01T00:00:00.000Z",
               "providerStatus": "pending",
@@ -526,7 +659,7 @@ describe('receiveWebhook', () => {
   })
 
   test('acknowledges unattributed and unknown addresses without dispatching', async () => {
-    const dispatched: FundingProvider.Webhook.receive.Dispatchable[] = []
+    const dispatched: RoutesProvider.Webhook.receive.Dispatchable[] = []
     const outcomes: Relay.relay.WebhookResult[] = []
     const { webhook } = webhookProvider(
       async (message) => {