tapimo 0.7.1 → 0.7.2

package/src/apps/data/routes/zones.test.ts

@@ -0,0 +1,473 @@
+/** @module-tag localnet */
+
+import { AbiEvent, AbiParameters, type Hex } from 'ox'
+
+import * as TestApp from '../../../../test/App.js'
+import * as Runtime from '../../../../test/runtime.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Schema from '../../../internal/Schema.js'
+import type * as Viem from '../../../internal/Viem.js'
+import * as Zones from './zones.js'
+
+const runtime = Runtime.get()
+const portal = Schema.Address.parse('0x59831A17340EE14FE136d751EfbeA8b630470fD2')
+const senderTag = Schema.Hash.parse(
+  '0x61fc42a734cb44acef497ea0bed612c691195623244136e0739e1929569e2487',
+)
+const otherSenderTag = Schema.Hash.parse(
+  '0x71fc42a734cb44acef497ea0bed612c691195623244136e0739e1929569e2487',
+)
+const completedSenderTag = Schema.Hash.parse(
+  '0x479ebbe3732639186397e0b0ee1e996a3e8a94d2ee8cd9fc833c02299eca28a2',
+)
+const failedSenderTag = Schema.Hash.parse(
+  '0x500570222c9b2c198638f14f66cea1d37de5a1b86b0880151d42cd2b3f4d5804',
+)
+const transactionHash = Schema.Hash.parse(
+  '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665',
+)
+const withdrawalProcessedEvent = AbiEvent.from(
+  'event WithdrawalProcessed(address indexed to, bytes32 indexed senderTag, address token, uint128 amount, bool callbackSuccess)',
+)
+const withdrawalProcessedData = AbiParameters.from(['address', 'uint128', 'bool'])
+const recipient = Schema.Address.parse('0xbe058e1c4df8a4366a387bf595b284246a93039e')
+const token = Schema.Address.parse('0x20c0000000000000000000000000000000000000')
+
+type OpenApiDocument = {
+  paths: {
+    '/v1/zones/withdrawals/{senderTag}'?: {
+      get?: {
+        operationId?: string
+        parameters?: readonly {
+          name: string
+          required?: boolean
+          schema?: { examples?: readonly unknown[] }
+        }[]
+        responses?: {
+          200?: {
+            content?: {
+              'application/json'?: {
+                examples?: Record<string, unknown>
+                schema?: {
+                  properties?: {
+                    data?: {
+                      items?: {
+                        properties?: Record<string, { examples?: readonly unknown[] }>
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          400?: {
+            content?: {
+              'application/json'?: {
+                schema?: {
+                  properties?: {
+                    error?: {
+                      properties?: {
+                        code?: { enum?: readonly string[] }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+const zoneReader = {
+  id: 'key_zone_withdrawal',
+  orgId: 'org_test',
+  scopes: ['data:read', `zone:${runtime.zone.chainId}:read`],
+  token: 'secret_zone_withdrawal',
+} satisfies TestApp.kvStore.Key
+
+function client(options: { keys?: readonly TestApp.kvStore.Key[] | undefined } = {}) {
+  return TestApp.client({
+    auth: { keys: options.keys ?? [zoneReader] },
+    zones: [
+      TestApp.zone({
+        chainId: runtime.zone.chainId,
+        rpcUrl: runtime.zone.internalRpcUrl,
+        sourceChainId: runtime.chainId as Viem.ChainId,
+      }),
+    ],
+  })
+}
+
+function auth(key: TestApp.kvStore.Key = zoneReader) {
+  return { headers: { authorization: `Bearer ${key.token}` } }
+}
+
+function row(
+  options: {
+    blockNumber?: number | undefined
+    callbackSuccess?: boolean | undefined
+    logIndex?: number | undefined
+    senderTag?: Hex.Hex | undefined
+  } = {},
+): Record<string, unknown> {
+  const tag = options.senderTag ?? senderTag
+  const { topics } = AbiEvent.encode(withdrawalProcessedEvent, {
+    senderTag: tag,
+    to: recipient,
+  })
+  const [selector, topic1, topic2] = topics
+  if (typeof selector !== 'string' || typeof topic1 !== 'string' || typeof topic2 !== 'string')
+    throw new Error('Unable to encode WithdrawalProcessed fixture topics')
+
+  return {
+    address: portal,
+    block_num: options.blockNumber ?? 123,
+    data: AbiParameters.encode(withdrawalProcessedData, [
+      token,
+      1_000_000n,
+      options.callbackSuccess ?? true,
+    ]),
+    log_idx: options.logIndex ?? 4,
+    selector,
+    topic1,
+    topic2,
+    tx_hash: transactionHash,
+  }
+}
+
+describe('resolveWithdrawalProcessed', () => {
+  test('returns failed when the callback failed', () => {
+    expect(
+      Zones.resolveWithdrawalProcessed({
+        portal,
+        rows: [row({ callbackSuccess: false })],
+        senderTag,
+        tempoBlockNumber: 123n,
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "data": [
+          {
+            "blockNumber": 123,
+            "id": "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-4",
+            "logIndex": 4,
+            "status": "failed",
+            "transactionHash": "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665",
+            "zoneStatus": "completed",
+          },
+        ],
+      }
+    `)
+  })
+
+  test('returns completed when the callback succeeded', () => {
+    expect(
+      Zones.resolveWithdrawalProcessed({
+        portal,
+        rows: [row()],
+        senderTag,
+        tempoBlockNumber: 122n,
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "data": [
+          {
+            "blockNumber": 123,
+            "id": "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-4",
+            "logIndex": 4,
+            "status": "completed",
+            "transactionHash": "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665",
+            "zoneStatus": "pending",
+          },
+        ],
+      }
+    `)
+  })
+
+  test('rejects malformed indexed events', () => {
+    expect(() =>
+      Zones.resolveWithdrawalProcessed({
+        portal,
+        rows: [{ ...row(), data: '0x00' }],
+        senderTag,
+        tempoBlockNumber: 123n,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: Upstream returned a malformed WithdrawalProcessed event]`,
+    )
+  })
+
+  test('returns every distinct event sharing one sender tag', () => {
+    expect(
+      Zones.resolveWithdrawalProcessed({
+        portal,
+        rows: [row({ callbackSuccess: false }), row({ blockNumber: 124, logIndex: 5 })],
+        senderTag,
+        tempoBlockNumber: 123n,
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "data": [
+          {
+            "blockNumber": 123,
+            "id": "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-4",
+            "logIndex": 4,
+            "status": "failed",
+            "transactionHash": "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665",
+            "zoneStatus": "completed",
+          },
+          {
+            "blockNumber": 124,
+            "id": "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-5",
+            "logIndex": 5,
+            "status": "completed",
+            "transactionHash": "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665",
+            "zoneStatus": "pending",
+          },
+        ],
+      }
+    `)
+  })
+
+  test('rejects an event carrying a different sender tag', () => {
+    expect(() =>
+      Zones.resolveWithdrawalProcessed({
+        portal,
+        rows: [row({ senderTag: otherSenderTag })],
+        senderTag,
+        tempoBlockNumber: 123n,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: Upstream returned a malformed WithdrawalProcessed event]`,
+    )
+  })
+})
+
+describe('GET /v1/zones/withdrawals/:senderTag', () => {
+  test.runIf(runtime.mode === 'testnet')(
+    'returns terminal L1 outcomes before Zone catch-up',
+    async () => {
+      for (const [tag, expected] of [
+        [
+          completedSenderTag,
+          {
+            blockNumber: 27_801_150,
+            id: '0x7daa6cf6b493d2455232a536f8fb121e2620361eb71341f390a9e07d90142fc6-114',
+            logIndex: 114,
+            status: 'completed',
+            transactionHash: '0x7daa6cf6b493d2455232a536f8fb121e2620361eb71341f390a9e07d90142fc6',
+            zoneStatus: 'completed',
+          },
+        ],
+        [
+          failedSenderTag,
+          {
+            blockNumber: 27_801_149,
+            id: '0xde78af3b44ec95385efcd3b045bb9a641194a0ba5d9470dc1ca9dec4037e9b80-104',
+            logIndex: 104,
+            status: 'failed',
+            transactionHash: '0xde78af3b44ec95385efcd3b045bb9a641194a0ba5d9470dc1ca9dec4037e9b80',
+            zoneStatus: 'completed',
+          },
+        ],
+      ] as const) {
+        const response = await client().v1.zones.withdrawals[':senderTag'].$get(
+          {
+            param: { senderTag: tag },
+            query: { chainId: String(runtime.zone.chainId) },
+          },
+          auth(),
+        )
+        const body = await TestApp.json(response, Zones.schema.listZoneWithdrawals.Response)
+
+        expect(response.status).toBe(200)
+        expect(response.headers.get('cache-control')).toBe('no-store')
+        expect(response.headers.get('server-timing')).toContain('zone_status;dur=')
+        expect(response.headers.get('server-timing')).toContain('zone_withdrawal;dur=')
+        expect(body).toEqual({ data: [expected] })
+      }
+    },
+  )
+
+  test.runIf(runtime.mode === 'localnet')(
+    'returns an empty list for sender tags absent from the parent Tempo indexer',
+    async () => {
+      const response = await client().v1.zones.withdrawals[':senderTag'].$get(
+        {
+          param: { senderTag },
+          query: { chainId: String(runtime.zone.chainId) },
+        },
+        auth(),
+      )
+      const body = await TestApp.json(response, Zones.schema.listZoneWithdrawals.Response)
+
+      expect(response.status).toBe(200)
+      expect(response.headers.get('cache-control')).toBe('no-store')
+      expect(response.headers.get('server-timing')).not.toContain('zone_status;dur=')
+      expect(response.headers.get('server-timing')).toContain('zone_withdrawal;dur=')
+      expect(body).toEqual({ data: [] })
+    },
+  )
+
+  test('requires the matching Zone read scope', async () => {
+    const otherReader = {
+      id: 'key_other_zone_withdrawal',
+      orgId: 'org_test',
+      scopes: ['data:read', `zone:${runtime.zone.chainId + 1}:read`],
+      token: 'secret_other_zone_withdrawal',
+    } satisfies TestApp.kvStore.Key
+    const response = await client({ keys: [otherReader] }).v1.zones.withdrawals[':senderTag'].$get(
+      {
+        param: { senderTag },
+        query: { chainId: String(runtime.zone.chainId) },
+      },
+      auth(otherReader),
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toBe(403)
+    expect(body.error.code).toBe('api_key_forbidden')
+    expect(body.error.message).toBe(
+      `Chain id ${runtime.zone.chainId} is a zone. Use an API key granting \`zone:${runtime.zone.chainId}:read\` or \`zone:${runtime.zone.chainId}:write\`.`,
+    )
+  })
+
+  test('requires an authenticated API key', async () => {
+    const response = await client().v1.zones.withdrawals[':senderTag'].$get(
+      {
+        param: { senderTag },
+        query: { chainId: String(runtime.zone.chainId) },
+      },
+      { headers: { authorization: 'Bearer invalid' } },
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toBe(401)
+    expect(body.error.code).toBe('api_key_invalid')
+  })
+
+  test('rejects invalid sender tags and chain ids', async () => {
+    const app = TestApp.create({
+      auth: { keys: [zoneReader] },
+      zones: [
+        TestApp.zone({
+          chainId: runtime.zone.chainId,
+          rpcUrl: runtime.zone.internalRpcUrl,
+          sourceChainId: runtime.chainId as Viem.ChainId,
+        }),
+      ],
+    })
+    const invalidSenderTag = await app.request(
+      `/v1/zones/withdrawals/not-a-tag?chainId=${runtime.zone.chainId}`,
+      auth(),
+    )
+    const invalidSenderTagBody = await TestApp.json(invalidSenderTag, Schema.ErrorResponse)
+    const invalidChainId = await app.request(
+      `/v1/zones/withdrawals/${senderTag}?chainId=nope`,
+      auth(),
+    )
+    const invalidChainIdBody = await TestApp.json(invalidChainId, Schema.ErrorResponse)
+    const missingChainId = await app.request(`/v1/zones/withdrawals/${senderTag}`, auth())
+    const missingChainIdBody = await TestApp.json(missingChainId, Schema.ErrorResponse)
+
+    expect(invalidSenderTag.status).toBe(400)
+    expect(invalidSenderTagBody.error.code).toBe('sender_tag_invalid')
+    expect(invalidChainId.status).toBe(400)
+    expect(invalidChainIdBody.error.code).toBe('chain_id_invalid')
+    expect(missingChainId.status).toBe(400)
+    expect(missingChainIdBody.error.code).toBe('query_invalid')
+  })
+
+  test('requires API-key access without public or MPP lanes', () => {
+    expect(Auth.describeAccess(Zones.zones())['listZoneWithdrawals']).toMatchInlineSnapshot(`
+        {
+          "apiKey": true,
+          "mpp": false,
+          "public": false,
+          "scopes": [
+            "data:read",
+          ],
+          "session": false,
+        }
+      `)
+  })
+
+  test('documents parameters, examples, and response variants', async () => {
+    const app = TestApp.create({ auth: false })
+    const document = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
+    const operation = document.paths['/v1/zones/withdrawals/{senderTag}']?.get
+    if (!operation) throw new Error('Missing Zone withdrawal OpenAPI operation')
+
+    expect(operation.operationId).toBe('listZoneWithdrawals')
+    expect(
+      operation.parameters?.map((parameter) => ({
+        examples: parameter.schema?.examples,
+        name: parameter.name,
+        required: parameter.required,
+      })),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "examples": [
+            "0x61fc42a734cb44acef497ea0bed612c691195623244136e0739e1929569e2487",
+          ],
+          "name": "senderTag",
+          "required": true,
+        },
+        {
+          "examples": [
+            421700001,
+          ],
+          "name": "chainId",
+          "required": true,
+        },
+      ]
+    `)
+
+    const response = operation.responses?.[200]?.content?.['application/json']
+    expect(Object.keys(response?.examples ?? {}).sort()).toEqual(['empty', 'processed'])
+    expect(
+      operation.responses?.[400]?.content?.['application/json']?.schema?.properties?.error
+        ?.properties?.code?.enum,
+    ).toEqual([
+      'api_key_malformed',
+      'chain_id_invalid',
+      'chain_id_unsupported',
+      'query_invalid',
+      'sender_tag_invalid',
+    ])
+    expect(
+      Object.fromEntries(
+        Object.entries(response?.schema?.properties?.data?.items?.properties ?? {}).map(
+          ([name, property]) => [name, property.examples],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "blockNumber": [
+          123,
+        ],
+        "id": [
+          "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-4",
+        ],
+        "logIndex": [
+          4,
+        ],
+        "status": [
+          "failed",
+          "completed",
+        ],
+        "transactionHash": [
+          "0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665",
+        ],
+        "zoneStatus": [
+          "pending",
+          "completed",
+        ],
+      }
+    `)
+  })
+})