tapimo 0.7.0 → 0.7.2

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

@@ -1,3 +1,5 @@
+/** @module-tag localnet */
+
 import type * as z from 'zod/mini'
 import { Address, Value as core_Value } from 'ox'
 import { Db, Schema } from 'tapimo'
@@ -11,8 +13,8 @@ import * as Runtime from '../../../../test/runtime.js'
 import * as Exchanges from './exchanges.js'
 
 type JsonSchema = {
+  anyOf?: readonly JsonSchema[]
   examples?: readonly unknown[]
-  oneOf?: readonly JsonSchema[]
   properties?: Record<string, JsonSchema>
   required?: readonly string[]
 }
@@ -40,6 +42,24 @@ const fixed = FxOracle.from({
   }),
 })
 
+describe('schema.createQuote.TypedData', () => {
+  test('accepts provider-specific EIP-712 types', () => {
+    expect(
+      Exchanges.schema.createQuote.TypedData.safeParse({
+        domain: { chainId: 4217, name: 'Market Maker' },
+        message: { amount: '1000000', recipient: Relay.accounts[1]!.address },
+        primaryType: 'MarketOrder',
+        types: {
+          MarketOrder: [
+            { name: 'amount', type: 'uint256' },
+            { name: 'recipient', type: 'address' },
+          ],
+        },
+      }).success,
+    ).toBe(true)
+  })
+})
+
 type Client = ReturnType<typeof TestApp.client>
 type OrdersQuery = {
   chainId?: string
@@ -605,7 +625,7 @@ describe('GET /exchange/swaps', () => {
   test('validates denominations without swap rows', async () => {
     const client = TestApp.client({ fx: { oracle: fixed } })
     const response = await client.v1.exchange.swaps.$get(
-      { query: { denomination: 'JPY', transactionHash: zeroHash } },
+      { query: { transactionHash: zeroHash, 'valuation.currency': 'JPY' } },
       TestApp.auth,
     )
     expect(response.status).toBe(400)
@@ -633,7 +653,7 @@ describe('GET /exchange/swaps', () => {
       const client = TestApp.client({ db, fx: { oracle: fixed } })
 
       const response = await client.v1.exchange.swaps.$get(
-        { query: { denomination: 'AUD', limit: '10' } },
+        { query: { limit: '10', 'valuation.currency': 'AUD' } },
         TestApp.auth,
       )
       expect(response.status).toBe(200)
@@ -654,7 +674,7 @@ describe('GET /exchange/swaps', () => {
           amount: core_Value.format((BigInt(leg.baseUnits) * 16n) / 10n, 6),
           currency: 'AUD',
         })
-      expect(body.meta?.pricing).toMatchInlineSnapshot(`
+      expect(body.meta?.valuation).toMatchInlineSnapshot(`
         {
           "asOf": "2026-01-01T00:00:00.000Z",
           "basis": "nominal",
@@ -823,13 +843,14 @@ describe('POST /exchange/quotes', () => {
     const response = await client.v1.exchange.quotes.$post(
       {
         json: {
+          account: Relay.accounts[1]!.address,
           amount: '1',
           destinationToken: Addresses.pathUsd,
           mode: 'exactSource',
           slippageBps: 50,
           sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
         },
-        query: { denomination: 'JPY' },
+        query: { 'valuation.currency': 'JPY' },
       },
       TestApp.auth,
     )
@@ -867,6 +888,7 @@ describe('POST /exchange/quotes', () => {
     const response = await TestApp.client().v1.exchange.quotes.$post(
       {
         json: {
+          account: Relay.accounts[1]!.address,
           amount: '1000000',
           destinationToken,
           mode: 'exactSource',
@@ -889,39 +911,42 @@ describe('POST /exchange/quotes', () => {
 
     const requestSchema = operation.requestBody?.content?.['application/json']?.schema
     const requestExample = Object.fromEntries(
-      ['amount', 'destinationToken', 'mode', 'slippageBps', 'sourceToken'].map((property) => [
-        property,
-        requestSchema?.properties?.[property]?.examples?.[0],
-      ]),
+      ['account', 'amount', 'destinationToken', 'mode', 'slippageBps', 'sourceToken'].map(
+        (property) => [property, requestSchema?.properties?.[property]?.examples?.[0]],
+      ),
     )
-    expect(requestExample).toEqual({
+    expect(requestExample).toMatchObject({
       amount: '1000000',
       destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
       mode: 'exactSource',
       slippageBps: 50,
       sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
     })
+    expect(requestExample['account']).toMatch(/^0x[\da-f]{40}$/)
     expect(Exchanges.schema.createQuote.Request.safeParse(requestExample).success).toBe(true)
 
     const responseSchema = operation.responses?.['200']?.content?.['application/json']?.schema
-    for (const [variant, names] of [
-      [responseSchema?.oneOf?.[0], ['destinationAmount', 'destinationAmountMin', 'sourceAmount']],
-      [responseSchema?.oneOf?.[1], ['destinationAmount', 'sourceAmount', 'sourceAmountMax']],
+    const variants = responseSchema?.anyOf
+    if (!variants) throw new Error('Missing create quote response variants')
+    for (const [variants_amount, names] of [
+      [variants.slice(0, 3), ['destinationAmount', 'destinationAmountMin', 'sourceAmount']],
+      [variants.slice(3), ['destinationAmount', 'sourceAmount', 'sourceAmountMax']],
     ] as const)
-      for (const name of names) {
-        const amount = variant?.properties?.[name]
-        expect(amount?.required).toEqual(['baseUnits', 'currency', 'decimals', 'formatted'])
-        expect(
-          Object.fromEntries(
-            ['baseUnits', 'currency', 'decimals', 'formatted'].map((property) => [
-              property,
-              amount?.properties?.[property]?.examples?.[0],
-            ]),
-          ),
-        ).toEqual({ baseUnits: '1000000', currency: 'USD', decimals: 6, formatted: '1' })
-      }
+      for (const variant of variants_amount)
+        for (const name of names) {
+          const amount = variant?.properties?.[name]
+          expect(amount?.required).toEqual(['baseUnits', 'currency', 'decimals', 'formatted'])
+          expect(
+            Object.fromEntries(
+              ['baseUnits', 'currency', 'decimals', 'formatted'].map((property) => [
+                property,
+                amount?.properties?.[property]?.examples?.[0],
+              ]),
+            ),
+          ).toEqual({ baseUnits: '1000000', currency: 'USD', decimals: 6, formatted: '1' })
+        }
 
-    for (const variant of responseSchema?.oneOf ?? [])
+    for (const variant of variants)
       for (const name of ['destinationToken', 'sourceToken']) {
         const token = variant.properties?.[name]
         expect(token?.required).toEqual(['address', 'currency', 'decimals', 'name', 'symbol'])
@@ -932,8 +957,8 @@ describe('POST /exchange/quotes', () => {
         expect(token?.required).not.toContain('verified')
       }
 
-    const callsExample =
-      responseSchema?.oneOf?.[0]?.properties?.['transaction']?.properties?.['calls']?.examples?.[0]
+    const callsExample = variants.find((variant) => variant.properties?.['transaction'])
+      ?.properties?.['transaction']?.properties?.['calls']?.examples?.[0]
     if (!Array.isArray(callsExample)) throw new Error('Missing create quote call examples')
     const calls = callsExample.map((call) => Exchanges.schema.createQuote.Call.parse(call))
     expect(decodeFunctionData({ abi: Abis.tip20, data: calls[0]!.data })).toEqual({
@@ -949,6 +974,15 @@ describe('POST /exchange/quotes', () => {
       ],
       functionName: 'swapExactAmountIn',
     })
+
+    const typedData = variants.find((variant) => variant.properties?.['typedData'])?.properties?.[
+      'typedData'
+    ]
+    expect(typedData?.properties?.['primaryType']?.examples).toEqual(['PermitSingle'])
+    expect(typedData?.properties?.['domain']?.examples?.[0]).toMatchObject({
+      chainId: 4217,
+      name: 'Permit2',
+    })
   })
 
   describe.skipIf(Runtime.get().mode !== 'localnet')('localnet quotes', () => {
@@ -1004,6 +1038,7 @@ describe('POST /exchange/quotes', () => {
       await TestApp.verifiedSeed(db, Runtime.get().chainId, { tokens: [] })
       const client = TestApp.client({ db })
       const request = {
+        account: account.address,
         amount: '1',
         destinationToken: Addresses.pathUsd,
         mode: 'exactSource',
@@ -1018,6 +1053,8 @@ describe('POST /exchange/quotes', () => {
       if (response.status !== 200) throw new Error(await response.text())
 
       const body = await TestApp.json(response, Exchanges.schema.createQuote.Response)
+      expect(body.status).toBe('ready')
+      if (body.status !== 'ready') throw new Error('Expected an executable quote')
       if (body.mode !== 'exactSource') throw new Error('Expected an exact-source exchange quote')
       expect(body.destinationAmount).toEqual({
         baseUnits: '1',
@@ -1071,6 +1108,7 @@ describe('POST /exchange/quotes', () => {
       await TestApp.verifiedSeed(db, Runtime.get().chainId, { tokens: [] })
       const client = TestApp.client({ db })
       const request = {
+        account: account.address,
         amount: '1',
         destinationToken: baseToken,
         mode: 'exactDestination',
@@ -1085,6 +1123,8 @@ describe('POST /exchange/quotes', () => {
       if (response.status !== 200) throw new Error(await response.text())
 
       const body = await TestApp.json(response, Exchanges.schema.createQuote.Response)
+      expect(body.status).toBe('ready')
+      if (body.status !== 'ready') throw new Error('Expected an executable quote')
       if (body.mode !== 'exactDestination')
         throw new Error('Expected an exact-destination exchange quote')
       expect(body.destinationAmount).toEqual({
@@ -1102,7 +1142,13 @@ describe('POST /exchange/quotes', () => {
       expect(body.destinationToken).not.toHaveProperty('amount')
       expect(body.destinationToken).not.toHaveProperty('logoUri')
       expect(body.destinationToken).not.toHaveProperty('verified')
-      expect(body.sourceAmountMax).toEqual(body.destinationAmount)
+      expect(body.sourceAmountMax).toEqual({
+        baseUnits: '2',
+        currency: 'USD',
+        decimals: 6,
+        formatted: '0.000002',
+        valuation: null,
+      })
       expect(body.sourceAmount).toEqual(body.destinationAmount)
       expect(body.sourceToken).toMatchObject({
         address: Addresses.pathUsd,
@@ -1118,13 +1164,13 @@ describe('POST /exchange/quotes', () => {
       expect(
         decodeFunctionData({ abi: Abis.tip20, data: body.transaction.calls[0]!.data }),
       ).toEqual({
-        args: [Address.checksum(Addresses.stablecoinDex), 1n],
+        args: [Address.checksum(Addresses.stablecoinDex), 2n],
         functionName: 'approve',
       })
       expect(
         decodeFunctionData({ abi: Abis.stablecoinDex, data: body.transaction.calls[1]!.data }),
       ).toEqual({
-        args: [Address.checksum(Addresses.pathUsd), Address.checksum(baseToken), 1n, 1n],
+        args: [Address.checksum(Addresses.pathUsd), Address.checksum(baseToken), 1n, 2n],
         functionName: 'swapExactAmountOut',
       })
     }, 60_000)
@@ -1149,13 +1195,14 @@ describe('POST /exchange/quotes', () => {
       const response = await client.v1.exchange.quotes.$post(
         {
           json: {
+            account: account.address,
             amount: '1000000',
             destinationToken: Addresses.pathUsd,
             mode: 'exactSource',
             slippageBps: 50,
             sourceToken: baseToken,
           },
-          query: { denomination: 'aud' },
+          query: { 'valuation.currency': 'aud' },
         },
         TestApp.auth,
       )
@@ -1167,7 +1214,7 @@ describe('POST /exchange/quotes', () => {
         amount: core_Value.format((BigInt(body.destinationAmount.baseUnits) * 16n) / 10n, 6),
         currency: 'AUD',
       })
-      expect(body.meta?.pricing).toMatchInlineSnapshot(`
+      expect(body.meta?.valuation).toMatchInlineSnapshot(`
         {
           "asOf": "2026-01-01T00:00:00.000Z",
           "basis": "nominal",
@@ -1180,6 +1227,7 @@ describe('POST /exchange/quotes', () => {
       const response = await TestApp.client().v1.exchange.quotes.$post(
         {
           json: {
+            account: account.address,
             amount: (2n ** 128n - 1n).toString(),
             destinationToken: baseToken,
             mode: 'exactSource',
@@ -1203,6 +1251,7 @@ describe('POST /exchange/quotes', () => {
         const response = await TestApp.client().v1.exchange.quotes.$post(
           {
             json: {
+              account: account.address,
               amount: '1',
               destinationToken: Addresses.pathUsd,
               mode: 'exactSource',