tapimo 0.7.2 → 0.9.0

package/src/apps/funding/routes/providers.test.ts

@@ -0,0 +1,165 @@
+import * as FundingCatalog from '../../../internal/funding/Catalog.js'
+
+import * as FundingProvider from '../../../internal/funding/Provider.js'
+
+import * as Across from '../../../internal/funding/providers/across.js'
+
+import * as Relay from '../../../internal/funding/providers/relay.js'
+
+import * as Rhino from '../../../internal/funding/providers/rhino.js'
+
+import * as Squid from '../../../internal/funding/providers/squid.js'
+
+import * as Symbiosis from '../../../internal/funding/providers/symbiosis.js'
+
+import * as Store from '../../../internal/Store.js'
+
+import * as TestApp from '../../../../test/App.js'
+
+import * as TestFunding from '../../../../test/Funding.js'
+
+import * as Funding from './providers.js'
+
+const db = TestApp.database()
+
+const providers = [
+  Across.across({
+    apiKey: 'across-api-key',
+    integratorId: '0xdead',
+    userAddress: '0x1111111111111111111111111111111111111111',
+  }),
+  Relay.relay({ userAddress: '0x1111111111111111111111111111111111111111' }),
+  Rhino.rhino(),
+  Squid.squid({
+    integratorId: 'squid-integrator-id',
+    userAddress: '0x1111111111111111111111111111111111111111',
+  }),
+  Symbiosis.symbiosis({ userAddress: '0x1111111111111111111111111111111111111111' }),
+] as const
+
+beforeAll(() => TestFunding.publish(db))
+
+function create(options: TestApp.create.Options = {}) {
+  return TestApp.create({ ...options, db })
+}
+
+describe('GET /funding/providers', () => {
+  test('lists supplied quote providers', async () => {
+    const app = create({ providers: [relayProvider()] })
+    const response = await app.request('/v1/funding/providers', {
+      headers: TestApp.auth.headers,
+    })
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.getFundingProviders.Response)
+
+    expect(body.data).toEqual([
+      {
+        id: 'relay',
+        name: 'Relay',
+      },
+    ])
+  })
+
+  test('isolates cached inventories between apps', async () => {
+    const store = Store.memory()
+    const relayApp = create({ cache: { store }, providers: [relayProvider()] })
+    const acrossApp = create({ cache: { store }, providers: [acrossProvider()] })
+
+    const relayResponse = await relayApp.request('/v1/funding/providers', {
+      headers: TestApp.auth.headers,
+    })
+    const acrossResponse = await acrossApp.request('/v1/funding/providers', {
+      headers: TestApp.auth.headers,
+    })
+    const relayBody = await TestApp.json(relayResponse, Funding.schema.getFundingProviders.Response)
+    const acrossBody = await TestApp.json(
+      acrossResponse,
+      Funding.schema.getFundingProviders.Response,
+    )
+
+    expect(relayBody.data.map((provider) => provider.id)).toEqual(['relay'])
+    expect(acrossBody.data.map((provider) => provider.id)).toEqual(['across'])
+  })
+
+  test('isolates cached inventories between database sources', async () => {
+    const first = TestApp.database()
+    const second = TestApp.database()
+    const store = Store.memory()
+    await TestFunding.publish(first)
+    await FundingCatalog.publish(second, { ...TestFunding.data, routes: [] })
+    const firstApp = TestApp.create({ cache: { store }, db: first, providers: [relayProvider()] })
+    const secondApp = TestApp.create({ cache: { store }, db: second, providers: [relayProvider()] })
+
+    const firstResponse = await firstApp.request('/v1/funding/providers', {
+      headers: TestApp.auth.headers,
+    })
+    const secondResponse = await secondApp.request('/v1/funding/providers', {
+      headers: TestApp.auth.headers,
+    })
+    const firstBody = await TestApp.json(firstResponse, Funding.schema.getFundingProviders.Response)
+    const secondBody = await TestApp.json(
+      secondResponse,
+      Funding.schema.getFundingProviders.Response,
+    )
+
+    expect(firstBody.data.map((provider) => provider.id)).toEqual(['relay'])
+    expect(secondBody.data).toEqual([])
+  })
+
+  test('does not expose the removed generic provider endpoint', async () => {
+    const response = await create().request('/v1/providers', {
+      headers: TestApp.auth.headers,
+    })
+    expect(response.status).toBe(404)
+  })
+})
+
+function relayProvider(onGetQuote: () => void = () => {}) {
+  return withGetQuote('relay', async (input, signal) => {
+    onGetQuote()
+    expect(signal.aborted).toBe(false)
+    expect(input.candidate.id).toBe('base-usdc-tempo-usdce-relay')
+    return {
+      destinationAmountMin: '980000',
+      destinationAmount: '990000',
+      quality: {
+        estimatedSeconds: 4,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'relay:quote-v2',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00Z',
+      status: 'available',
+    }
+  })
+}
+
+function acrossProvider(onGetQuote: () => void = () => {}) {
+  return withGetQuote('across', async (input, signal) => {
+    onGetQuote()
+    expect(signal.aborted).toBe(false)
+    expect(input.candidate.id).toBe('base-usdc-tempo-usdce-across')
+    return {
+      expiresAt: '2026-01-01T00:01:00Z',
+      destinationAmountMin: '988000',
+      destinationAmount: '990000',
+      quality: {
+        estimatedSeconds: 2,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'across:swap-approval',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00Z',
+      status: 'available',
+    }
+  })
+}
+
+function withGetQuote(
+  id: FundingProvider.ProviderId,
+  getQuote: FundingProvider.Provider['getQuote'],
+) {
+  const provider = providers.find((entry) => entry.id === id)
+  if (!provider) throw new Error(`Missing ${id} provider`)
+  return FundingProvider.from({ ...provider, getQuote })
+}

package/src/apps/funding/routes/providers.ts

@@ -0,0 +1,73 @@
+import { Hono } from 'hono'
+import * as z from 'zod/mini'
+
+import type * as App from '../../../App.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Cache from '../../../internal/Cache.js'
+import * as FundingCatalog from '../../../internal/funding/Catalog.js'
+import * as FundingProvider from '../../../internal/funding/Provider.js'
+import * as OpenApi from '../../../internal/OpenApi.js'
+import * as Response from '../../../internal/Response.js'
+import * as Schema from '../../../internal/Schema.js'
+import * as Inventory from '../Inventory.js'
+
+/** Zod schemas owned by funding provider resources. */
+export namespace schema {
+  /** Funding provider catalog entry. */
+  export const Provider = Schema.describe(
+    FundingProvider.schema.ProviderRef,
+    'One funding quote provider.',
+  )
+
+  /** Schemas for the getFundingProviders operation. */
+  export namespace getFundingProviders {
+    /** Non-paginated funding provider catalog. */
+    export const Response = Schema.describe(
+      z.object({
+        data: z.array(Provider).check(z.describe("Providers in Tempo's funding quote catalog.")),
+      }),
+      'A non-paginated list of funding quote providers.',
+    )
+  }
+}
+
+const providersResponseExample = {
+  data: [{ id: 'relay', name: 'Relay' }],
+} satisfies z.output<typeof schema.getFundingProviders.Response>
+
+/** Mounts funding provider inventory routes. */
+export function providers() {
+  return new Hono<App.Environment>().get(
+    '/v1/funding/providers',
+    Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
+    OpenApi.describeRoute({
+      description: 'Lists available transfer providers.',
+      operationId: 'getFundingProviders',
+      responses: OpenApi.responses({
+        success: {
+          description: 'Funding quote providers supported by Tempo.',
+          example: providersResponseExample,
+          schema: schema.getFundingProviders.Response,
+        },
+      }),
+      summary: 'Get providers',
+      tags: ['Providers'],
+    }),
+    Cache.response<App.Environment>({
+      cacheControl: Cache.policies.stable,
+      key: Inventory.key,
+      name: 'tempo-api:funding-providers:v4',
+    }),
+    async (c) => {
+      if (Auth.narrowAccess) return Auth.paidAccessError(c)
+      const catalog = await FundingCatalog.snapshot(c)
+      const providers = c.get('providers').filter(FundingProvider.is)
+      return c.json(
+        Response.validated(schema.getFundingProviders.Response, {
+          data: FundingProvider.getProviders({ catalog, providers }),
+        }),
+        200,
+      )
+    },
+  )
+}