tapimo 0.11.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,29 @@ 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
+  examples?: readonly unknown[] | undefined
+  properties?: Record<string, JsonSchema> | undefined
+  required?: readonly string[] | undefined
+}
+
+type ComponentSpec = {
+  components: { schemas: Record<string, JsonSchema> }
+}
+
+function dereference(spec: ComponentSpec, schema: JsonSchema): JsonSchema {
+  if (!schema.$ref) return schema
+  const name = schema.$ref.split('/').at(-1)!
+  return spec.components.schemas[name]!
+}
+
 describe('GET /funding/transfers', () => {
   test('requires the funding:read scope', async () => {
     const app = transfersApp()
@@ -359,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 = [
@@ -590,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)
@@ -609,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,
         })
       }
@@ -629,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) {
@@ -738,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({
@@ -766,33 +1167,23 @@ describe('funding transfers OpenAPI', () => {
 
   test('publishes human-readable deposit address route examples', async () => {
     const app = create({ auth: false })
-    type Property = { examples: string[] }
     type Operation = {
       requestBody: {
-        content: Record<
-          string,
-          {
-            schema: {
-              properties: {
-                destinationToken: Property
-                sourceChain: Property
-                sourceToken: Property
-              }
-            }
-          }
-        >
+        content: Record<string, { schema: JsonSchema }>
       }
     }
-    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 properties =
+    const properties = dereference(
+      spec,
       spec.paths['/v1/funding/deposit-addresses']!.post.requestBody.content['application/json']!
-        .schema.properties
+        .schema,
+    ).properties!
 
     expect({
-      destinationToken: properties.destinationToken.examples,
-      sourceChain: properties.sourceChain.examples,
-      sourceToken: properties.sourceToken.examples,
+      destinationToken: properties['destinationToken']!.examples,
+      sourceChain: properties['sourceChain']!.examples,
+      sourceToken: properties['sourceToken']!.examples,
     }).toMatchInlineSnapshot(`
       {
         "destinationToken": [
@@ -949,30 +1340,22 @@ describe('funding transfers OpenAPI', () => {
 
   test('publishes concrete creation schemas', async () => {
     const app = create({ auth: false })
-    const spec = (await (await app.request('/openapi.json')).json()) as {
+    type Spec = ComponentSpec & {
       paths: Record<
         string,
         {
           post?: {
             requestBody: {
-              content: Record<
-                string,
-                {
-                  schema: {
-                    additionalProperties?: boolean
-                    properties: object
-                    required?: readonly string[] | undefined
-                  }
-                }
-              >
+              content: Record<string, { schema: JsonSchema }>
             }
             responses: Record<string, unknown>
           }
         }
       >
     }
+    const spec = (await (await app.request('/openapi.json')).json()) as Spec
     const creationSchema = (path: string) =>
-      spec.paths[path]!.post!.requestBody.content['application/json']!.schema
+      dereference(spec, spec.paths[path]!.post!.requestBody.content['application/json']!.schema)
     expect(
       creationSchema('/v1/funding/deposit-addresses').required?.includes('subsidize') ?? false,
     ).toMatchInlineSnapshot(`false`)
@@ -980,7 +1363,7 @@ describe('funding transfers OpenAPI', () => {
       const schema = creationSchema(path)
       return {
         additionalProperties: schema.additionalProperties,
-        properties: Object.keys(schema.properties),
+        properties: Object.keys(schema.properties!),
       }
     }
 
@@ -1002,6 +1385,7 @@ describe('funding transfers OpenAPI', () => {
             "amount",
             "destinationToken",
             "mode",
+            "provider",
             "recipient",
             "sender",
             "slippageBps",
@@ -1025,11 +1409,13 @@ describe('funding transfers OpenAPI', () => {
           "200",
           "400",
           "401",
+          "403",
           "404",
           "409",
           "429",
           "500",
           "502",
+          "504",
         ],
         "vault": {
           "additionalProperties": false,
@@ -1047,9 +1433,11 @@ describe('funding transfers OpenAPI', () => {
         "vaultResponses": [
           "400",
           "401",
+          "403",
           "429",
           "500",
           "501",
+          "504",
         ],
         "zone": {
           "additionalProperties": false,
@@ -1069,9 +1457,11 @@ describe('funding transfers OpenAPI', () => {
         "zoneResponses": [
           "400",
           "401",
+          "403",
           "429",
           "500",
           "501",
+          "504",
         ],
       }
     `)