tapimo 0.12.0 → 0.13.0

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

@@ -16,6 +16,8 @@ import * as Idempotency from '../../../internal/Idempotency.js'
 
 import * as Relay from '../../../internal/funding/providers/relay.js'
 
+import * as Stargate from '../../../internal/funding/providers/stargate.js'
+
 import * as TestApp from '../../../../test/App.js'
 
 import * as TestFunding from '../../../../test/Funding.js'
@@ -29,8 +31,14 @@ const executableProviders = [
   {
     create: (_sender: string) =>
       Relay.relay(process.env.RELAY_API_KEY ? { apiKey: process.env.RELAY_API_KEY } : {}),
+    destinationToken: 'pathusd',
     id: 'relay',
   },
+  {
+    create: (_sender: string) => Stargate.stargate(),
+    destinationToken: 'usdce',
+    id: 'stargate',
+  },
 ] as const
 
 beforeAll(() => TestFunding.publish(db))
@@ -39,6 +47,11 @@ function create(options: TestApp.create.Options = {}) {
   return TestApp.create({ ...options, db })
 }
 
+type ContractResponse = {
+  $ref?: string | undefined
+  content?: Record<string, { schema: unknown }> | undefined
+}
+
 type JsonSchema = {
   $ref?: string | undefined
   additionalProperties?: boolean | undefined
@@ -377,6 +390,69 @@ describe('POST /funding/transfers', () => {
     expect(row.providerState).toEqual({ requestId: `0x${'ab'.repeat(32)}` })
   })
 
+  test('creates a transfer with the requested provider', async () => {
+    const app = transfersApp({ providers: [provider()] })
+    const response = await postTransfer(app, {
+      body: { ...createBody, provider: 'relay' },
+      idempotencyKey: nextIdempotencyKey(),
+    })
+
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.createFundingTransfer.Response)
+    expect(body.provider.id).toBe('relay')
+  })
+
+  test('rejects an unsupported provider', async () => {
+    const app = transfersApp({ providers: [provider()] })
+    const response = await postTransfer(app, {
+      body: { ...createBody, provider: 'bridge' },
+      idempotencyKey: nextIdempotencyKey(),
+    })
+
+    expect(response.status).toBe(400)
+    expect(((await response.json()) as { error: { code: string } }).error.code).toBe('body_invalid')
+  })
+
+  test('preserves a provider-specified native fee token', async () => {
+    const app = transfersApp({
+      providers: [
+        provider(async () => ({
+          ...providerResponse(),
+          fees: [
+            {
+              amount: '1000000000000000',
+              side: 'source',
+              token: {
+                address: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+                currency: 'ETH',
+                decimals: 18,
+                name: 'Ether',
+                standard: 'native',
+                symbol: 'ETH',
+                tokenKey: 'eip155:8453/slip44:60',
+                verified: true,
+              },
+            },
+          ],
+        })),
+      ],
+    })
+    const response = await postTransfer(app, {
+      body: { ...createBody, destinationToken: 'pathusd', sourceToken: 'usdc' },
+      idempotencyKey: nextIdempotencyKey(),
+    })
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.createFundingTransfer.Response)
+
+    expect(body.fees).toMatchObject([
+      {
+        amount: { baseUnits: '1000000000000000', formatted: '0.001' },
+        side: 'source',
+        token: { standard: 'native', symbol: 'ETH' },
+      },
+    ])
+  })
+
   test('resolves token identifiers through the composed route', async () => {
     const app = transfersApp({ providers: [provider()] })
     const identifiers = [
@@ -608,7 +684,7 @@ describe.skipIf(!Anvil.available)('POST /funding/transfers (forked localnet)', (
         (entry) =>
           entry.route.source.chain.id === `eip155:${base.id}` &&
           entry.route.source.symbol === 'USDC' &&
-          entry.route.destination.slug === 'pathusd',
+          entry.route.destination.slug === executable.destinationToken,
       )!
       const usdc = route.route.source
       const amount = Value.from('10', usdc.decimals)
@@ -627,7 +703,12 @@ describe.skipIf(!Anvil.available)('POST /funding/transfers (forked localnet)', (
       function createTransfer(idempotencyKey: string) {
         const app = transfersApp({ providers: [executable.create(sender.address)] })
         return postTransfer(app, {
-          body: { ...createBody, amount: amount.toString(), sender: sender.address },
+          body: {
+            ...createBody,
+            amount: amount.toString(),
+            destinationToken: executable.destinationToken,
+            sender: sender.address,
+          },
           idempotencyKey,
         })
       }
@@ -647,6 +728,14 @@ describe.skipIf(!Anvil.available)('POST /funding/transfers (forked localnet)', (
         expect(transfer.action.type).toBe('evm:calls')
         if (transfer.action.type !== 'evm:calls') return
         expect(transfer.action.calls.length).toBeGreaterThan(0)
+        if (executable.id === 'stargate')
+          expect(transfer.fees).toMatchObject([
+            {
+              amount: { baseUnits: BigInt(transfer.action.calls.at(-1)!.value).toString() },
+              side: 'source',
+              token: { standard: 'native', symbol: 'ETH' },
+            },
+          ])
 
         const receipts = []
         for (const call of transfer.action.calls) {
@@ -756,24 +845,318 @@ describe('POST /funding/transfers/{destination}', () => {
 })
 
 describe('funding transfers OpenAPI', () => {
+  test('publishes generator-ready transfer contracts', async () => {
+    const spec = await (await create({ auth: false }).request('/openapi.json')).json()
+    const detailPath = Object.keys(spec.paths).find((path) =>
+      path.includes('/v1/funding/transfers/{'),
+    )!
+    const operations = {
+      create: spec.paths['/v1/funding/transfers'].post,
+      createVault: spec.paths['/v1/funding/transfers/vault'].post,
+      createZone: spec.paths['/v1/funding/transfers/zone'].post,
+      get: spec.paths[detailPath].get,
+      list: spec.paths['/v1/funding/transfers'].get,
+    }
+    const summarize = (operation: (typeof operations)[keyof typeof operations]) => ({
+      errors: Object.fromEntries(
+        (Object.entries(operation.responses) as [string, ContractResponse][])
+          .filter(([status]) => Number(status) >= 400)
+          .map(([status, response]) => [
+            status,
+            response.$ref ?? response.content?.['application/json']?.schema,
+          ]),
+      ),
+      operationId: operation.operationId,
+      request: operation.requestBody?.content['application/json'].schema,
+      response: operation.responses[200]?.content?.['application/json']?.schema,
+    })
+
+    expect({
+      components: [
+        'CreateFundingTransferRequest',
+        'CreateFundingTransferVaultRequest',
+        'CreateFundingTransferZoneRequest',
+        'CreatedFundingTransfer',
+        'FundingAction',
+        'FundingActionCall',
+        'FundingEvmCallsAction',
+        'FundingTransfer',
+        'FundingTransferFee',
+        'FundingTransferList',
+        'FundingTransferQuote',
+        'FundingTransferStatusReason',
+      ].filter((name) => spec.components.schemas[name]),
+      formats: {
+        createdAt: spec.components.schemas.FundingTransfer.properties.createdAt.format,
+        quoteExpiresAt: spec.components.schemas.FundingTransferQuote.properties.expiresAt.format,
+        quoteSampledAt: spec.components.schemas.FundingTransferQuote.properties.sampledAt.format,
+        updatedAt: spec.components.schemas.FundingTransfer.properties.updatedAt.format,
+      },
+      models: {
+        action: spec.components.schemas.FundingAction.oneOf,
+        createdAction: spec.components.schemas.CreatedFundingTransfer.properties.action,
+        evmCall: spec.components.schemas.FundingEvmCallsAction.properties.calls.items,
+        feeToken: spec.components.schemas.FundingTransferFee.properties.token,
+        list: spec.components.schemas.FundingTransferList.properties.data.items,
+        quote: spec.components.schemas.FundingTransfer.properties.quote,
+        statusReason: spec.components.schemas.FundingTransfer.properties.statusReason,
+      },
+      operations: {
+        create: summarize(operations.create),
+        createVault: summarize(operations.createVault),
+        createZone: summarize(operations.createZone),
+        get: summarize(operations.get),
+        list: summarize(operations.list),
+      },
+      operationErrorCodes: {
+        createInvalid:
+          spec.components.schemas.ApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError
+            .properties.error.properties.code.enum,
+        idempotencyConflict:
+          spec.components.schemas.IdempotencyConflictOrIdempotencyInProgressError.properties.error
+            .properties.code.enum,
+        notImplemented:
+          spec.components.schemas.NotImplemented501Error.properties.error.properties.code.enum,
+        parametersInvalid:
+          spec.components.schemas.ApiKeyMalformedOrParamInvalidError.properties.error.properties
+            .code.enum,
+        queryInvalid:
+          spec.components.schemas.ApiKeyMalformedOrQueryInvalidError.properties.error.properties
+            .code.enum,
+        quoteNotAvailable:
+          spec.components.schemas.QuoteNotAvailableError.properties.error.properties.code.enum,
+        transferNotFound:
+          spec.components.schemas.FundingTransferNotFoundError.properties.error.properties.code
+            .enum,
+      },
+    }).toMatchInlineSnapshot(`
+      {
+        "components": [
+          "CreateFundingTransferRequest",
+          "CreateFundingTransferVaultRequest",
+          "CreateFundingTransferZoneRequest",
+          "CreatedFundingTransfer",
+          "FundingAction",
+          "FundingActionCall",
+          "FundingEvmCallsAction",
+          "FundingTransfer",
+          "FundingTransferFee",
+          "FundingTransferList",
+          "FundingTransferQuote",
+          "FundingTransferStatusReason",
+        ],
+        "formats": {
+          "createdAt": "date-time",
+          "quoteExpiresAt": "date-time",
+          "quoteSampledAt": "date-time",
+          "updatedAt": "date-time",
+        },
+        "models": {
+          "action": [
+            {
+              "$ref": "#/components/schemas/FundingEvmCallsAction",
+            },
+          ],
+          "createdAction": {
+            "$ref": "#/components/schemas/FundingAction",
+          },
+          "evmCall": {
+            "$ref": "#/components/schemas/FundingActionCall",
+          },
+          "feeToken": {
+            "$ref": "#/components/schemas/FundingToken",
+          },
+          "list": {
+            "$ref": "#/components/schemas/FundingTransfer",
+          },
+          "quote": {
+            "$ref": "#/components/schemas/FundingTransferQuote",
+          },
+          "statusReason": {
+            "$ref": "#/components/schemas/FundingTransferStatusReason",
+          },
+        },
+        "operationErrorCodes": {
+          "createInvalid": [
+            "api_key_malformed",
+            "body_invalid",
+            "idempotency_key_required",
+          ],
+          "idempotencyConflict": [
+            "idempotency_conflict",
+            "idempotency_in_progress",
+          ],
+          "notImplemented": [
+            "not_implemented",
+          ],
+          "parametersInvalid": [
+            "api_key_malformed",
+            "param_invalid",
+          ],
+          "queryInvalid": [
+            "api_key_malformed",
+            "query_invalid",
+          ],
+          "quoteNotAvailable": [
+            "quote_not_available",
+          ],
+          "transferNotFound": [
+            "funding_transfer_not_found",
+          ],
+        },
+        "operations": {
+          "create": {
+            "errors": {
+              "400": {
+                "$ref": "#/components/schemas/ApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError",
+              },
+              "401": {
+                "$ref": "#/components/schemas/AuthenticationError",
+              },
+              "403": {
+                "$ref": "#/components/schemas/ForbiddenError",
+              },
+              "404": {
+                "$ref": "#/components/schemas/QuoteNotAvailableError",
+              },
+              "409": {
+                "$ref": "#/components/schemas/IdempotencyConflictOrIdempotencyInProgressError",
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "$ref": "#/components/schemas/UpstreamError",
+              },
+              "504": "#/components/responses/RequestTimeout",
+            },
+            "operationId": "createFundingTransfer",
+            "request": {
+              "$ref": "#/components/schemas/CreateFundingTransferRequest",
+            },
+            "response": {
+              "$ref": "#/components/schemas/CreatedFundingTransfer",
+            },
+          },
+          "createVault": {
+            "errors": {
+              "400": {
+                "$ref": "#/components/schemas/ApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError",
+              },
+              "401": {
+                "$ref": "#/components/schemas/AuthenticationError",
+              },
+              "403": {
+                "$ref": "#/components/schemas/ForbiddenError",
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "501": {
+                "$ref": "#/components/schemas/NotImplemented501Error",
+              },
+              "504": "#/components/responses/RequestTimeout",
+            },
+            "operationId": "createFundingTransferVault",
+            "request": {
+              "$ref": "#/components/schemas/CreateFundingTransferVaultRequest",
+            },
+            "response": undefined,
+          },
+          "createZone": {
+            "errors": {
+              "400": {
+                "$ref": "#/components/schemas/ApiKeyMalformedOrBodyInvalidOrIdempotencyKeyRequiredError",
+              },
+              "401": {
+                "$ref": "#/components/schemas/AuthenticationError",
+              },
+              "403": {
+                "$ref": "#/components/schemas/ForbiddenError",
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "501": {
+                "$ref": "#/components/schemas/NotImplemented501Error",
+              },
+              "504": "#/components/responses/RequestTimeout",
+            },
+            "operationId": "createFundingTransferZone",
+            "request": {
+              "$ref": "#/components/schemas/CreateFundingTransferZoneRequest",
+            },
+            "response": undefined,
+          },
+          "get": {
+            "errors": {
+              "400": {
+                "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidError",
+              },
+              "401": {
+                "$ref": "#/components/schemas/AuthenticationError",
+              },
+              "403": {
+                "$ref": "#/components/schemas/ForbiddenError",
+              },
+              "404": {
+                "$ref": "#/components/schemas/FundingTransferNotFoundError",
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "$ref": "#/components/schemas/UpstreamError",
+              },
+              "504": "#/components/responses/RequestTimeout",
+            },
+            "operationId": "getFundingTransfer",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/FundingTransfer",
+            },
+          },
+          "list": {
+            "errors": {
+              "400": {
+                "$ref": "#/components/schemas/ApiKeyMalformedOrQueryInvalidError",
+              },
+              "401": {
+                "$ref": "#/components/schemas/AuthenticationError",
+              },
+              "403": {
+                "$ref": "#/components/schemas/ForbiddenError",
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "$ref": "#/components/schemas/UpstreamError",
+              },
+              "504": "#/components/responses/RequestTimeout",
+            },
+            "operationId": "listFundingTransfers",
+            "request": undefined,
+            "response": {
+              "$ref": "#/components/schemas/FundingTransferList",
+            },
+          },
+        },
+      }
+    `)
+  })
+
   test('publishes an executable account transfer example', async () => {
     const app = create({ auth: false })
-    type TokenSchema = { examples: string[] }
     type TransferExample = { destinationToken: { address: string } }
     type Operation = {
       requestBody: {
-        content: Record<string, { schema: { properties: { destinationToken: TokenSchema } } }>
+        content: Record<string, { schema: JsonSchema }>
       }
       responses: Record<string, { content: Record<string, { example: TransferExample }> }>
     }
-    type Spec = { paths: Record<string, { post: Operation }> }
+    type Spec = ComponentSpec & { paths: Record<string, { post: Operation }> }
     const spec = (await (await app.request('/openapi.json')).json()) as Spec
     const operation = spec.paths['/v1/funding/transfers']!.post
+    const request = dereference(spec, operation.requestBody.content['application/json']!.schema)
 
     expect({
-      request:
-        operation.requestBody.content['application/json']!.schema.properties.destinationToken
-          .examples,
+      request: request.properties!['destinationToken']!.examples,
       response:
         operation.responses['200']!.content['application/json']!.example.destinationToken.address,
     }).toEqual({
@@ -1002,6 +1385,7 @@ describe('funding transfers OpenAPI', () => {
             "amount",
             "destinationToken",
             "mode",
+            "provider",
             "recipient",
             "sender",
             "slippageBps",
@@ -1031,6 +1415,7 @@ describe('funding transfers OpenAPI', () => {
           "429",
           "500",
           "502",
+          "504",
         ],
         "vault": {
           "additionalProperties": false,
@@ -1052,6 +1437,7 @@ describe('funding transfers OpenAPI', () => {
           "429",
           "500",
           "501",
+          "504",
         ],
         "zone": {
           "additionalProperties": false,
@@ -1075,6 +1461,7 @@ describe('funding transfers OpenAPI', () => {
           "429",
           "500",
           "501",
+          "504",
         ],
       }
     `)

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

@@ -36,15 +36,20 @@ export namespace schema {
       .check(z.describe('Query parameters for listing funding transfers.'))
 
     /** Paginated funding transfer list. */
-    export const Response = z
-      .object({
-        data: z.array(Transfer).check(z.describe('Funding transfers on this page, newest first.')),
-        meta: z
-          .optional(Schema.CountMeta)
-          .check(z.describe('Extra response metadata requested with `include`.')),
-        nextCursor: Schema.NextCursor,
-      })
-      .check(z.describe('A page of funding transfers.'))
+    export const Response = OpenApi.component(
+      z
+        .object({
+          data: z
+            .array(Transfer)
+            .check(z.describe('Funding transfers on this page, newest first.')),
+          meta: z
+            .optional(Schema.CountMeta)
+            .check(z.describe('Extra response metadata requested with `include`.')),
+          nextCursor: Schema.NextCursor,
+        })
+        .check(z.describe('A page of funding transfers.')),
+      'FundingTransferList',
+    )
   }
 
   /** Schemas for the createFundingTransfer operation. */
@@ -82,18 +87,21 @@ export namespace schema {
   /** Schemas for the createFundingTransferVault operation. */
   export namespace createFundingTransferVault {
     /** Funding transfer creation request for an Earn vault destination. */
-    export const Body = z
-      .strictObject({
-        ...destinationCreateFields,
-        vaultAddress: z
-          .string()
-          .check(
-            z.regex(/^0x[0-9a-fA-F]{40}$/),
-            z.describe('Tempo Earn vault contract address.'),
-            z.meta({ examples: [`0x${'f4'.repeat(20)}`] }),
-          ),
-      })
-      .check(z.describe('Vault funding transfer creation request.'))
+    export const Body = OpenApi.component(
+      z
+        .strictObject({
+          ...destinationCreateFields,
+          vaultAddress: z
+            .string()
+            .check(
+              z.regex(/^0x[0-9a-fA-F]{40}$/),
+              z.describe('Tempo Earn vault contract address.'),
+              z.meta({ examples: [`0x${'f4'.repeat(20)}`] }),
+            ),
+        })
+        .check(z.describe('Vault funding transfer creation request.')),
+      'CreateFundingTransferVaultRequest',
+    )
 
     /** Required headers for vault funding transfer creation. */
     export const Headers = createFundingTransfer.Headers
@@ -102,32 +110,35 @@ export namespace schema {
   /** Schemas for the createFundingTransferZone operation. */
   export namespace createFundingTransferZone {
     /** Funding transfer creation request for a Zone destination. */
-    export const Body = z
-      .strictObject({
-        amount: destinationCreateFields.amount,
-        destinationChain: z
-          .string()
-          .check(
-            z.regex(/^eip155:\d+$/),
-            z.describe('Configured Zone CAIP-2 id.'),
-            z.meta({ examples: ['eip155:1424310001'] }),
-          ),
-        destinationToken: FundingTransfer.schema.CreateRequest.shape.destinationToken,
-        mode: destinationCreateFields.mode,
-        recipient: destinationCreateFields.recipient,
-        recipientFallback: z
-          .string()
-          .check(
-            z.regex(/^0x[0-9a-fA-F]{40}$/),
-            z.describe('Public Tempo recipient used if the Zone credit cannot complete.'),
-            z.meta({ examples: [`0x${'22'.repeat(20)}`] }),
-          ),
-        sender: destinationCreateFields.sender,
-        slippageBps: destinationCreateFields.slippageBps,
-        sourceChain: destinationCreateFields.sourceChain,
-        sourceToken: destinationCreateFields.sourceToken,
-      })
-      .check(z.describe('Zone funding transfer creation request.'))
+    export const Body = OpenApi.component(
+      z
+        .strictObject({
+          amount: destinationCreateFields.amount,
+          destinationChain: z
+            .string()
+            .check(
+              z.regex(/^eip155:\d+$/),
+              z.describe('Configured Zone CAIP-2 id.'),
+              z.meta({ examples: ['eip155:1424310003'] }),
+            ),
+          destinationToken: FundingTransfer.schema.CreateRequest.shape.destinationToken,
+          mode: destinationCreateFields.mode,
+          recipient: destinationCreateFields.recipient,
+          recipientFallback: z
+            .string()
+            .check(
+              z.regex(/^0x[0-9a-fA-F]{40}$/),
+              z.describe('Public Tempo recipient used if the Zone credit cannot complete.'),
+              z.meta({ examples: [`0x${'22'.repeat(20)}`] }),
+            ),
+          sender: destinationCreateFields.sender,
+          slippageBps: destinationCreateFields.slippageBps,
+          sourceChain: destinationCreateFields.sourceChain,
+          sourceToken: destinationCreateFields.sourceToken,
+        })
+        .check(z.describe('Zone funding transfer creation request.')),
+      'CreateFundingTransferZoneRequest',
+    )
 
     /** Required headers for Zone funding transfer creation. */
     export const Headers = createFundingTransfer.Headers
@@ -516,6 +527,7 @@ export function transfers() {
             method: 'transaction',
             mode: body.mode,
             onAttempt: (attempt) => attempts.push(attempt),
+            provider: body.provider,
             providers,
             recipient: body.recipient,
             sender: body.sender,
@@ -532,8 +544,6 @@ export function transfers() {
           }
 
           const { candidate, result } = selected
-          const feeToken = (side: 'destination' | 'source') =>
-            side === 'source' ? candidate.sourceToken : candidate.destinationToken
           const snapshot: FundingTransfer.Snapshot = {
             destinationAmount: Value.tokenAmount({
               baseUnits: result.destinationAmount,
@@ -547,16 +557,21 @@ export function transfers() {
             }),
             destinationChain: candidate.destinationChain,
             destinationToken: candidate.destinationToken,
-            fees: result.fees.map((fee) => ({
-              amount: Value.tokenAmount({
-                baseUnits: fee.amount,
-                currency: feeToken(fee.side).currency,
-                decimals: feeToken(fee.side).decimals,
-              }),
-              side: fee.side,
-              token: feeToken(fee.side),
-              type: 'provider',
-            })),
+            fees: result.fees.map((fee) => {
+              const token =
+                fee.token ??
+                (fee.side === 'source' ? candidate.sourceToken : candidate.destinationToken)
+              return {
+                amount: Value.tokenAmount({
+                  baseUnits: fee.amount,
+                  currency: token.currency,
+                  decimals: token.decimals,
+                }),
+                side: fee.side,
+                token,
+                type: 'provider',
+              }
+            }),
             method: 'transaction',
             mode: body.mode,
             provider: candidate.provider,
@@ -604,6 +619,8 @@ export function transfers() {
           await release()
           if (cause instanceof FundingProvider.InvalidAmountError)
             return Response.error(c, { code: 'body_invalid', message: 'Invalid `amount`.', status: 400 }) // prettier-ignore
+          if (cause instanceof FundingProvider.UnsupportedProviderError)
+            return Response.error(c, { code: 'body_invalid', message: 'Unsupported `provider`.', status: 400 }) // prettier-ignore
           if (cause instanceof FundingProvider.UnsupportedSourceChainError)
             return quoteNotAvailable(c)
           if (cause instanceof FundingProvider.ProviderQuoteError) {