tapimo 0.19.0 → 0.20.0

package/src/admin/apps/routes-support.test.ts

@@ -151,7 +151,7 @@ const catalog = {
 } as const satisfies RoutesCatalog.publish.Input
 
 describe('GET /routes/support', () => {
-  test('groups partner-route capabilities and reports conditional subsidy eligibility', async () => {
+  test('groups route capabilities and reports conditional subsidy eligibility', async () => {
     const { app, db } = TestAdmin.setup()
     const published = await RoutesCatalog.publish(db, catalog)
     const response = await app.request('/routes/support')
@@ -161,6 +161,43 @@ describe('GET /routes/support', () => {
     expect({ ...body, updatedAt: '<updatedAt>' }).toMatchInlineSnapshot(`
       {
         "data": [
+          {
+            "depositAddressProviders": [
+              "relay",
+            ],
+            "destinationChain": {
+              "id": "eip155:4217",
+              "name": "Tempo",
+              "slug": "tempo",
+            },
+            "destinationToken": {
+              "address": "0x20c000000000000000000000b9537d11c60e8b50",
+              "id": "usdce",
+              "name": "Bridged USDC (Stargate)",
+              "symbol": "USDC.e",
+            },
+            "id": "eip155:1/dai-eip155:4217/usdce",
+            "sourceChain": {
+              "id": "eip155:1",
+              "name": "Ethereum",
+              "slug": "ethereum",
+            },
+            "sourceToken": {
+              "address": "0x6b175474e89094c44da98b954eedeac495271d0f",
+              "id": "dai",
+              "name": "Dai Stablecoin",
+              "symbol": "DAI",
+            },
+            "subsidies": {
+              "depositAddress": true,
+              "universalDepositAddress": true,
+              "walletTransfer": false,
+            },
+            "universalDepositAddressProviders": [
+              "relay",
+            ],
+            "walletTransferProviders": [],
+          },
           {
             "depositAddressProviders": [
               "relay",
@@ -205,6 +242,46 @@ describe('GET /routes/support', () => {
               },
             ],
           },
+          {
+            "depositAddressProviders": [],
+            "destinationChain": {
+              "id": "eip155:4217",
+              "name": "Tempo",
+              "slug": "tempo",
+            },
+            "destinationToken": {
+              "address": "0x20c000000000000000000000b9537d11c60e8b50",
+              "id": "usdce",
+              "name": "Bridged USDC (Stargate)",
+              "symbol": "USDC.e",
+            },
+            "id": "eip155:4217/usdc-eip155:4217/usdce",
+            "sourceChain": {
+              "id": "eip155:4217",
+              "name": "Tempo",
+              "slug": "tempo",
+            },
+            "sourceToken": {
+              "address": "0x20c0000000000000000000000000000000000001",
+              "id": "usdc",
+              "name": "USD Coin",
+              "symbol": "USDC",
+            },
+            "subsidies": {
+              "depositAddress": false,
+              "universalDepositAddress": false,
+              "walletTransfer": false,
+            },
+            "universalDepositAddressProviders": [],
+            "walletTransferProviders": [
+              {
+                "modes": [
+                  "exactSource",
+                ],
+                "providerId": "relay",
+              },
+            ],
+          },
           {
             "depositAddressProviders": [],
             "destinationChain": {
@@ -436,6 +513,174 @@ describe('GET /routes/support', () => {
     `)
   })
 
+  test('lists every capable catalog route', async () => {
+    const { app, db } = TestAdmin.setup()
+    const transfer = { transfer: { modes: ['exactSource'] } } as const
+    await RoutesCatalog.publish(db, {
+      chains: [
+        {
+          aliases: [],
+          id: 'eip155:4217',
+          name: 'Tempo',
+          parentChainId: null,
+          rpcUrls: ['https://tempo.example'],
+          slug: 'tempo',
+        },
+        {
+          aliases: [],
+          id: 'stellar:pubnet',
+          name: 'Stellar',
+          parentChainId: null,
+          rpcUrls: ['https://stellar.example'],
+          slug: 'stellar',
+        },
+      ],
+      chainTokens: [
+        {
+          address: '0x20c0000000000000000000006a37da5c996874be',
+          chainId: 'eip155:4217',
+          decimals: 6,
+          name: null,
+          standard: 'TIP-20',
+          tokenId: 'ousd',
+        },
+        {
+          address: '0x20c000000000000000000000b9537d11c60e8b50',
+          chainId: 'eip155:4217',
+          decimals: 6,
+          name: null,
+          standard: 'TIP-20',
+          tokenId: 'usdce',
+        },
+        {
+          address: '0x20c00000000000000000000014f22ca97301eb73',
+          chainId: 'eip155:4217',
+          decimals: 6,
+          name: null,
+          standard: 'TIP-20',
+          tokenId: 'usdt0',
+        },
+        {
+          address: 'USDC-GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN',
+          chainId: 'stellar:pubnet',
+          decimals: 7,
+          name: null,
+          standard: 'Stellar',
+          tokenId: 'usdc',
+        },
+      ],
+      routes: [
+        {
+          capabilities: { depositAddress: true, ...transfer },
+          destinationChainId: 'eip155:4217',
+          destinationTokenId: 'ousd',
+          providerId: 'rhino',
+          sourceChainId: 'stellar:pubnet',
+          sourceTokenId: 'usdc',
+        },
+        ...['ousd', 'usdce', 'usdt0'].map((destinationTokenId) => ({
+          capabilities: transfer,
+          destinationChainId: 'eip155:4217',
+          destinationTokenId,
+          providerId: 'squid',
+          sourceChainId: 'stellar:pubnet',
+          sourceTokenId: 'usdc',
+        })),
+      ],
+      tokens: [
+        { currency: 'USD', id: 'ousd', name: 'Open USD', symbol: 'OUSD' },
+        { currency: 'USD', id: 'usdc', name: 'USD Coin', symbol: 'USDC' },
+        { currency: 'USD', id: 'usdce', name: 'Bridged USDC (Stargate)', symbol: 'USDC.e' },
+        { currency: 'USD', id: 'usdt0', name: 'USDT0', symbol: 'USDT0' },
+      ],
+    })
+    const response = await app.request('/routes/support')
+    const body = await TestApp.json(response, RoutesSupport.schema.getRoutesSupport.Response)
+
+    expect(
+      body.data.map(
+        ({
+          depositAddressProviders,
+          id,
+          subsidies,
+          universalDepositAddressProviders,
+          walletTransferProviders,
+        }) => ({
+          depositAddressProviders,
+          id,
+          subsidies,
+          universalDepositAddressProviders,
+          walletTransferProviders,
+        }),
+      ),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "depositAddressProviders": [
+            "rhino",
+          ],
+          "id": "stellar:pubnet/usdc-eip155:4217/ousd",
+          "subsidies": {
+            "depositAddress": true,
+            "universalDepositAddress": false,
+            "walletTransfer": true,
+          },
+          "universalDepositAddressProviders": [],
+          "walletTransferProviders": [
+            {
+              "modes": [
+                "exactSource",
+              ],
+              "providerId": "rhino",
+            },
+            {
+              "modes": [
+                "exactSource",
+              ],
+              "providerId": "squid",
+            },
+          ],
+        },
+        {
+          "depositAddressProviders": [],
+          "id": "stellar:pubnet/usdc-eip155:4217/usdce",
+          "subsidies": {
+            "depositAddress": false,
+            "universalDepositAddress": false,
+            "walletTransfer": true,
+          },
+          "universalDepositAddressProviders": [],
+          "walletTransferProviders": [
+            {
+              "modes": [
+                "exactSource",
+              ],
+              "providerId": "squid",
+            },
+          ],
+        },
+        {
+          "depositAddressProviders": [],
+          "id": "stellar:pubnet/usdc-eip155:4217/usdt0",
+          "subsidies": {
+            "depositAddress": false,
+            "universalDepositAddress": false,
+            "walletTransfer": true,
+          },
+          "universalDepositAddressProviders": [],
+          "walletTransferProviders": [
+            {
+              "modes": [
+                "exactSource",
+              ],
+              "providerId": "squid",
+            },
+          ],
+        },
+      ]
+    `)
+  })
+
   test('lists Stablecoin DEX swaps between Tempo USDC.e and OUSD', async () => {
     const { app, db } = TestAdmin.setup()
     const transfer = { transfer: { modes: ['exactSource'] } } as const
@@ -531,7 +776,7 @@ describe('GET /routes/support', () => {
     `)
   })
 
-  test('lists Stablecoin DEX swaps between Tempo pathUSD and OUSD, USDC.e, or USDT0', async () => {
+  test('lists Stablecoin DEX swaps between Tempo pathUSD and other Tempo stablecoins', async () => {
     const { app, db } = TestAdmin.setup()
     const transfer = { transfer: { modes: ['exactSource'] } } as const
     const tokens = {
@@ -560,7 +805,6 @@ describe('GET /routes/support', () => {
         standard: 'TIP-20',
         tokenId,
       })),
-      // `pathusd` to `usdy` is not a partner route and stays hidden.
       routes: [
         ['ousd', 'pathusd'],
         ['pathusd', 'ousd'],
@@ -624,6 +868,13 @@ describe('GET /routes/support', () => {
           ],
           "walletTransfer": true,
         },
+        {
+          "id": "eip155:4217/pathusd-eip155:4217/usdy",
+          "providers": [
+            "stabledex",
+          ],
+          "walletTransfer": false,
+        },
         {
           "id": "eip155:4217/usdce-eip155:4217/pathusd",
           "providers": [

package/src/admin/apps/routes-support.ts

@@ -187,7 +187,7 @@ function summarize(routes: readonly RoutesCatalog.ProviderRoute[]) {
   for (const providerRoute of routes) {
     const { capabilities, providerId, route } = providerRoute
     // Routes without capabilities cannot be executed or priced, so they publish no support.
-    if (!capabilities || !isPartnerRoute(route)) continue
+    if (!capabilities) continue
     const id = RoutesSupport.id(route)
     const row = rows.get(id) ?? {
       depositAddressProviders: [],
@@ -226,49 +226,6 @@ function summarize(routes: readonly RoutesCatalog.ProviderRoute[]) {
   return [...rows.values()]
 }
 
-function isPartnerRoute(route: RoutesCatalog.ProviderRoute['route']) {
-  const { destination, source } = route
-  if (destination.chain.slug === 'tempo') {
-    if (source.chain.slug === 'tempo') {
-      const pair = [source.slug, destination.slug].sort().join('/')
-      return ['ousd/pathusd', 'ousd/usdce', 'pathusd/usdce', 'pathusd/usdt0'].includes(pair)
-    }
-    if (source.slug === 'usdc') {
-      if (['pathusd', 'whishusd'].includes(destination.slug)) return true
-      if (destination.slug === 'ousd' && ['hyperevm', 'monad'].includes(source.chain.slug))
-        return true
-      return (
-        ['base', 'ethereum', 'solana'].includes(source.chain.slug) &&
-        ['ousd', 'usdce', 'usdt0'].includes(destination.slug)
-      )
-    }
-    return (
-      source.chain.slug === 'tron' &&
-      source.slug === 'usdt' &&
-      ['ousd', 'pathusd', 'usdce', 'usdt0', 'whishusd'].includes(destination.slug)
-    )
-  }
-
-  if (source.chain.slug !== 'tempo') return false
-  if (destination.chain.slug === 'tempo') return false
-  if (destination.slug === 'usdc') {
-    if (['pathusd', 'whishusd'].includes(source.slug)) return true
-    if (source.slug === 'ousd' && ['hyperevm', 'monad'].includes(destination.chain.slug))
-      return true
-    if (source.slug === 'usdt0')
-      return ['base', 'ethereum', 'solana'].includes(destination.chain.slug)
-    return (
-      ['ousd', 'usdce'].includes(source.slug) &&
-      ['base', 'ethereum', 'solana'].includes(destination.chain.slug)
-    )
-  }
-  return (
-    destination.chain.slug === 'tron' &&
-    destination.slug === 'usdt' &&
-    ['ousd', 'pathusd', 'usdce', 'usdt0', 'whishusd'].includes(source.slug)
-  )
-}
-
 function pickChain(chain: RoutesCatalog.ProviderRoute['route']['source']['chain']) {
   return { id: chain.id, name: chain.name, slug: chain.slug }
 }

package/src/admin/apps/scopes.test.ts

@@ -85,9 +85,9 @@ describe('GET /scopes', () => {
             "selfServe": true,
           },
           {
-            "description": "Read RPC and indexed data for one zone chain id.",
-            "scope": "zone:<chainId>:read",
-            "selfServe": false,
+            "description": "Broadcast signed transactions to Zones the key is tagged for.",
+            "scope": "zone:write",
+            "selfServe": true,
           },
           {
             "description": "Broadcast signed transactions to one zone chain id.",

package/src/admin/apps/zone-delegation-requests.test.ts

@@ -0,0 +1,246 @@
+import * as Metrics from '../../Metrics.js'
+import * as Organizations from '../../db/tables/organizations.js'
+import * as Requests from '../../db/tables/zoneDelegationRequests.js'
+import * as ZoneDelegations from '../../db/tables/zoneDelegations.js'
+import type * as ZoneDelegationApproval from '../../internal/ZoneDelegationApproval.js'
+import * as TestAdmin from '../../../test/Admin.js'
+
+const chainId = 421_700_001
+
+describe('zoneDelegationRequests', () => {
+  test('a lookup outage blocks application, preserves the request, and emits the failure metric', async () => {
+    const member = employee('requester', false)
+    const counts: Parameters<Metrics.Metrics['count']>[] = []
+    const { app, db } = TestAdmin.setup({
+      delegationApproval: {
+        groupId,
+        identify: () => member,
+        lookup: async () => {
+          await fetch('http://127.0.0.1:1/unavailable')
+          return []
+        },
+      },
+      identify: () => member,
+      metrics: Metrics.from({
+        count(...parameters) {
+          counts.push(parameters)
+        },
+        flush() {},
+        gauge() {},
+        histogram() {},
+      }),
+    })
+    const org = await Organizations.create(db, { name: 'Zone outage' })
+    const request = await Requests.create(db, { groupId, input: input(org.id), requester: member })
+    for (const id of ['first', 'second'])
+      await Requests.approve(db, { groupId, id: request.id, lookup, member: employee(id, true) })
+    const response = await app.request(`/zone-delegation-requests/${request.id}/apply`, { method: 'POST' }) // prettier-ignore
+    expect(response.status).toBe(502)
+    expect((await Requests.get(db, request.id))?.status).toBe('pending')
+    expect(await ZoneDelegations.listActive(db, { environment: 'production', orgId: org.id })).toEqual([]) // prettier-ignore
+    expect(counts.filter(([name]) => name === 'zone_delegation_approval_failure_count')).toEqual([
+      ['zone_delegation_approval_failure_count', 1],
+    ])
+    expect((await app.request('/zone-delegations?orgId=' + org.id)).status).toBe(200)
+  })
+
+  test('ordinary staff request, two group members approve, and the requester applies once', async () => {
+    const member = employee('requester', false)
+    const { app, db } = TestAdmin.setup({
+      delegationApproval: {
+        groupId,
+        identify: () => member,
+        lookup: (_request, ids) => lookup(ids),
+      },
+      identify: () => member,
+    })
+    const org = await Organizations.create(db, { name: 'Zone requester' })
+    const created = await app.request('/zone-delegation-requests', {
+      body: JSON.stringify(input(org.id)),
+      headers: { 'content-type': 'application/json' },
+      method: 'POST',
+    })
+    expect(created.status).toBe(201)
+    const request = await created.json()
+    const path = `/zone-delegation-requests/${request.id}`
+    expect((await app.request(`${path}/approve`, { method: 'POST' })).status).toBe(403)
+    expect((await app.request(`${path}/apply`, { method: 'POST' })).status).toBe(403)
+    const nonmember = employee('nonmember', false)
+    const { app: nonmemberApp } = TestAdmin.setup({
+      db,
+      delegationApproval: { groupId, identify: () => nonmember, lookup: (_request, ids) => lookup(ids) }, // prettier-ignore
+      identify: () => nonmember,
+    })
+    expect((await nonmemberApp.request(`${path}/approve`, { method: 'POST' })).status).toBe(403)
+    for (const id of ['first', 'second']) {
+      const reviewer = employee(id, true)
+      const { app: review } = TestAdmin.setup({
+        db,
+        delegationApproval: { groupId, identify: () => reviewer, lookup: (_request, ids) => lookup(ids) }, // prettier-ignore
+        identify: () => reviewer,
+      })
+      expect((await review.request(path)).status).toBe(200)
+      expect((await review.request(`${path}/approve`, { method: 'POST' })).status).toBe(200)
+      expect((await review.request(`${path}/apply`, { method: 'POST' })).status).toBe(403)
+    }
+    const applied = await app.request(`${path}/apply`, { method: 'POST' })
+    expect(applied.status).toBe(200)
+    const { data } = await applied.json()
+    expect(data).toMatchObject({ accountsAll: true, chainId, orgId: org.id })
+    expect((await Requests.get(db, request.id))).toMatchObject({ delegationId: data.id, status: 'applied' }) // prettier-ignore
+    expect((await app.request(`${path}/apply`, { method: 'POST' })).status).toBe(403)
+    // A second request for the same Zone is consumed by its conflict and must be refiled.
+    const duplicate = await Requests.create(db, {
+      groupId,
+      input: input(org.id),
+      requester: member,
+    })
+    for (const id of ['first', 'second'])
+      await Requests.approve(db, { groupId, id: duplicate.id, lookup, member: employee(id, true) })
+    const conflict = await app.request(`/zone-delegation-requests/${duplicate.id}/apply`, { method: 'POST' }) // prettier-ignore
+    expect(conflict.status).toBe(409)
+    expect((await Requests.get(db, duplicate.id))?.status).toBe('failed')
+    // Cancelling and unknown owners stay single-step.
+    const pending = await Requests.create(db, { groupId, input: input(org.id), requester: member })
+    expect((await app.request(`/zone-delegation-requests/${pending.id}`, { method: 'DELETE' })).status).toBe(200) // prettier-ignore
+    expect((await app.request(`/zone-delegation-requests/${pending.id}`, { method: 'DELETE' })).status).toBe(404) // prettier-ignore
+    const unknown = await app.request('/zone-delegation-requests', {
+      body: JSON.stringify(input('org_missing')),
+      headers: { 'content-type': 'application/json' },
+      method: 'POST',
+    })
+    expect(unknown.status).toBe(404)
+  })
+
+  test('rejects missing, mismatched, and expired workflow identities without blocking other routes', async () => {
+    for (const member of [
+      null,
+      employee('different', true),
+      { ...employee('admin', true), expiresAt: new Date().toISOString() },
+    ]) {
+      const { app } = TestAdmin.setup({
+        delegationApproval: { groupId, identify: () => member, lookup: (_request, ids) => lookup(ids) }, // prettier-ignore
+      })
+      expect((await app.request('/zone-delegation-requests')).status).toBe(401)
+      expect((await app.request('/api-keys')).status).toBe(200)
+    }
+  })
+
+  test('requires admin authentication and fails closed until configured', async () => {
+    const anonymous = TestAdmin.setup({ identify: () => null })
+    expect((await anonymous.app.request('/zone-delegation-requests')).status).toBe(401)
+    const { app } = TestAdmin.setup()
+    const response = await app.request('/zone-delegation-requests')
+    expect(response.status).toBe(503)
+    expect((await response.json()).error.code).toBe('zone_delegation_approval_unconfigured')
+  })
+
+  test('pages through every request newest first', async () => {
+    const member = employee('requester', false)
+    const { app, db } = TestAdmin.setup({
+      delegationApproval: {
+        groupId,
+        identify: () => member,
+        lookup: (_request, ids) => lookup(ids),
+      },
+      identify: () => member,
+    })
+    const created = []
+    for (let index = 0; index < 51; index++)
+      created.push(
+        await Requests.create(db, {
+          groupId,
+          input: { ...input('org_fixture'), chainId: chainId + index },
+          requester: member,
+        }),
+      )
+    const first = await (await app.request('/zone-delegation-requests')).json()
+    expect(first.data).toHaveLength(50)
+    expect(first.nextCursor).toEqual(expect.any(String))
+    const second = await (
+      await app.request(`/zone-delegation-requests?cursor=${encodeURIComponent(first.nextCursor)}`)
+    ).json()
+    expect(second.nextCursor).toBeNull()
+    expect(
+      [...first.data, ...second.data].map((request: { id: string }) => request.id).sort(),
+    ).toEqual(created.map((request) => request.id).sort())
+    expect((await app.request('/zone-delegation-requests?cursor=invalid')).status).toBe(400)
+  })
+
+  test('reports approver group membership in the bootstrap config', async () => {
+    const counts: Parameters<Metrics.Metrics['count']>[] = []
+    const cases: readonly [Identify, boolean | null][] = [
+      [() => employee('approver', true), true],
+      [() => employee('approver', false), false],
+      [() => employee('approver', true, -1), false],
+      [() => ({ ...employee('approver', true), email: 'other@tempo.xyz' }), false],
+      [() => null, false],
+      [
+        () => {
+          throw new Error('not authenticated')
+        },
+        null,
+      ],
+    ]
+    for (const [identify, expected] of cases) {
+      const { app } = TestAdmin.setup({
+        delegationApproval: { groupId, identify, lookup: (_request, ids) => lookup(ids) },
+        identify: () => ({ email: 'approver@tempo.xyz' }),
+        metrics: Metrics.from({
+          count(...parameters) {
+            counts.push(parameters)
+          },
+          flush() {},
+          gauge() {},
+          histogram() {},
+        }),
+      })
+      const config = await (await app.request('/config.json')).json()
+      expect(config.auth.delegationApprover).toBe(expected)
+    }
+    expect(counts.filter(([name]) => name === 'zone_delegation_approval_failure_count')).toEqual([
+      ['zone_delegation_approval_failure_count', 1],
+    ])
+  })
+
+  test('rejects cross-origin approval mutations', async () => {
+    const { app } = TestAdmin.setup()
+    const response = await app.request('/zone-delegation-requests/zdr_fixture/approve', {
+      headers: { origin: 'https://other.example' },
+      method: 'POST',
+    })
+    expect(response.status).toBe(403)
+    expect((await response.json()).error.code).toBe('forbidden')
+  })
+})
+
+const groupId = 'app-tempo-api-zone-issuers'
+
+type Identify = () => ZoneDelegationApproval.Member | null
+
+function input(orgId: string) {
+  return {
+    accountsAll: true,
+    chainId,
+    environment: 'production' as const,
+    orgId,
+    tokensAll: true,
+  }
+}
+
+function employee(id: string, eligible: boolean, hours = 1): ZoneDelegationApproval.Member {
+  return {
+    email: `${id}@tempo.xyz`,
+    eligible,
+    expiresAt: new Date(Date.now() + hours * 3_600_000).toISOString(),
+    id: `employee_${id}`,
+  }
+}
+
+async function lookup(ids: readonly string[]): Promise<ZoneDelegationApproval.Status[]> {
+  return ids.map((id) => ({
+    active: true,
+    eligible: id !== 'employee_requester' && id !== 'employee_nonmember',
+    id,
+  }))
+}