tapimo 0.11.0 → 0.12.0

package/src/Client.test-d.ts

@@ -173,7 +173,7 @@ describe('narrows responses by status', () => {
         'apy.window': '24h',
         capability: 'deposit',
         'engine.type': 'erc4626',
-        include: 'access,apy,capabilities,token.logoUri,tvl,zone',
+        include: 'access,apy,capabilities,token.logoUri,tvl,zone,zones',
       },
     })
 
@@ -205,6 +205,8 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.vaultAddress).toEqualTypeOf<`0x${string}`>()
       expectTypeOf(json.data[0]!.verified).toEqualTypeOf<boolean>()
       expectTypeOf(json.data[0]!.zone?.chainId).toEqualTypeOf<number | undefined>()
+      expectTypeOf(json.data[0]!.zones?.[0]?.deploymentBlock).toEqualTypeOf<number | undefined>()
+      expectTypeOf(json.data[0]!.zones?.[0]?.earnRouter).toEqualTypeOf<`0x${string}` | undefined>()
       expectTypeOf(json.meta?.valuation?.basis).toEqualTypeOf<'nominal' | undefined>()
       void json
       return
@@ -226,7 +228,10 @@ describe('narrows responses by status', () => {
   test('GET /v1/earn/vaults/verified', async () => {
     const client = Client.create()
     const res = await client.v1.earn.vaults.verified.$get({
-      query: { 'apy.window': '7d', include: 'access,apy,capabilities,token.logoUri,tvl,zone' },
+      query: {
+        'apy.window': '7d',
+        include: 'access,apy,capabilities,token.logoUri,tvl,zone,zones',
+      },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
@@ -243,6 +248,7 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.tvl).toEqualTypeOf<VaultValue | null | undefined>()
       expectTypeOf(json.data[0]!.tvl?.formatted).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.data[0]!.verified).toEqualTypeOf<true>()
+      expectTypeOf(json.data[0]!.zones?.[0]?.chainId).toEqualTypeOf<number | undefined>()
       expectTypeOf(json.meta?.valuation?.source).toEqualTypeOf<string | undefined>()
       void json
       return
@@ -968,6 +974,46 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].$delete({
+      param: { orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'sponsorships_unreported'>()
+        void json
+        return
+      }
     }
   })
 
@@ -1035,10 +1081,21 @@ describe('narrows responses by status', () => {
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()
 
-    if (res.status === 200) {
-      const json = await res.json()
-      expectTypeOf(json.allowedIps).toEqualTypeOf<readonly string[]>()
-      void json
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.allowedIps).toEqualTypeOf<readonly string[]>()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
     }
   })
 
@@ -1053,6 +1110,14 @@ describe('narrows responses by status', () => {
     expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()
 
     switch (res.status) {
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
       case 404: {
         const json = await res.json()
         expectTypeOf(json.error.code).toEqualTypeOf<
@@ -1117,6 +1182,12 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
     }
   })
 
@@ -1129,6 +1200,50 @@ describe('narrows responses by status', () => {
     expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()
 
     switch (res.status) {
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'member_not_found' | 'organization_not_found'>()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'last_owner'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId/members/:userId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].members[
+      ':userId{usr_[A-Za-z0-9_-]+}'
+    ].$delete({ param: { orgId: 'org_test', userId: 'usr_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.userId).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'member_not_found' | 'organization_not_found'>()
+        void json
+        return
+      }
       case 409: {
         const json = await res.json()
         expectTypeOf(json.error.code).toEqualTypeOf<'last_owner'>()
@@ -1138,6 +1253,57 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('POST /v1/orgs/:orgId/invitations', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].invitations.$post({
+      json: { email: 'dev@example.com', role: 'member' },
+      param: { orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.email).toEqualTypeOf<string>()
+        expectTypeOf(json.role).toEqualTypeOf<'admin' | 'member' | 'owner'>()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
+        >()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId/invitations/:invitationId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].invitations[
+      ':invitationId{inv_[A-Za-z0-9_-]+}'
+    ].$delete({ param: { invitationId: 'inv_test', orgId: 'org_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()
+
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        'invitation_not_found' | 'organization_not_found'
+      >()
+      void json
+    }
+  })
+
   test('POST /v1/orgs/:orgId/invite-links', async () => {
     const client = Client.create()
     const orgLinks = client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['invite-links']
@@ -1157,13 +1323,57 @@ describe('narrows responses by status', () => {
     >()
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
 
-    if (res.status === 200) {
-      const json = await res.json()
-      expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<readonly string[] | null>()
-      expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<
-        z.output<typeof InviteLinks.schema.InviteLink>['allowedEmailDomains']
-      >()
-      void json
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<readonly string[] | null>()
+        expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<
+          z.output<typeof InviteLinks.schema.InviteLink>['allowedEmailDomains']
+        >()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('PATCH /v1/orgs/:orgId/invite-links/:inviteLinkId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['invite-links'][
+      ':inviteLinkId{iln_[A-Za-z0-9_-]+}'
+    ].$patch({
+      json: { enabled: false },
+      param: { inviteLinkId: 'iln_test', orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'invite_link_not_found' | 'organization_not_found'
+        >()
+        void json
+        return
+      }
     }
   })
 
@@ -1500,14 +1710,18 @@ describe('narrows responses by status', () => {
       param: {
         transactionHash: '0x4845ae2098724ab26a5d89370dce5124d044be6a5acc164afc348662de67d474',
       },
-      query: { include: 'token.logoUri,token.verified' },
+      query: {
+        chainId: '4217',
+        include: 'zones,token.logoUri,token.verified',
+      },
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PaidAccessStatus>()
 
     switch (res.status) {
       case 200: {
         const json = await res.json()
+        expectTypeOf(json.chainId).toEqualTypeOf<number>()
         expectTypeOf(json.data[0]!.type).toEqualTypeOf<
           z.output<
             typeof Activities.schema.getTransactionActivities.Response
@@ -1550,6 +1764,13 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'transaction_ambiguous'>()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
       case 502: {
         const json = await res.json()
         expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
@@ -2604,6 +2825,30 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('QUERY /v1/exchange/quotes', async () => {
+    const client = Client.create()
+    const res = await client.v1.exchange.quotes.$query({
+      json: {
+        account: '0x1111111111111111111111111111111111111111',
+        amount: '1000000',
+        destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
+        mode: 'exactSource',
+        slippageBps: 50,
+        sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
+      },
+      query: { include: 'token.logoUri,token.verified' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json.destinationAmount).toEqualTypeOf<ValuedTokenAmount>()
+      expectTypeOf(json.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
+      expectTypeOf(json.destinationToken.logoUri).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.sourceToken.verified).toEqualTypeOf<boolean | undefined>()
+    }
+  })
+
   test('POST /v1/exchange/quotes/execute', async () => {
     const client = Client.create()
     const res = await client.v1.exchange.quotes.execute.$post({
@@ -3292,7 +3537,10 @@ describe('narrows responses by status', () => {
     const client = Client.create()
     const res = await client.v1.addresses[':address'].activities.$get({
       param: { address: '0x0000000000000000000000000000000000000000' },
-      query: { include: 'token.logoUri,token.verified' },
+      query: {
+        chainId: '4217',
+        include: 'zones,token.logoUri,token.verified',
+      },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
@@ -3300,6 +3548,7 @@ describe('narrows responses by status', () => {
     switch (res.status) {
       case 200: {
         const json = await res.json()
+        expectTypeOf(json.data[0]!.chainId).toEqualTypeOf<number | undefined>()
         expectTypeOf(json.data[0]!.type).toEqualTypeOf<
           z.output<typeof Activities.schema.getAddressActivities.Response>['data'][number]['type']
         >()

package/src/admin/apps/earn-vaults.test.ts

@@ -20,6 +20,15 @@ const input = {
   privateOutputTokens: [],
   slug: 'btpathusd-earn',
   vaultAddress,
+  zones: [],
+} as const
+
+const zoneInput = {
+  ...input,
+  label: 'Moderato Earn',
+  slug: 'moderato-earn',
+  vaultAddress: TestEarn.zoneVaultAddress,
+  zones: [TestEarn.zoneRoute],
 } as const
 
 describe('authentication', () => {
@@ -179,6 +188,140 @@ describe('putVerifiedEarnVault', () => {
     expect(await response.json()).toMatchObject({ error: { code: 'body_invalid' } })
   })
 
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'rejects duplicate Zone routes',
+    async () => {
+      const { app } = TestAdmin.setup({ zones: [TestEarn.zone] })
+      const response = await app.request('/earn/verified-vaults', {
+        body: JSON.stringify({
+          ...zoneInput,
+          zones: [TestEarn.zoneRoute, TestEarn.zoneRoute],
+        }),
+        headers: { 'content-type': 'application/json' },
+        method: 'PUT',
+      })
+      expect(response.status).toBe(400)
+      expect(await response.json()).toMatchObject({
+        error: {
+          code: 'body_invalid',
+          details: [{ message: 'Zone 1424310001 is configured more than once.' }],
+        },
+      })
+    },
+    60_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'rejects a router bound to a different vault',
+    async () => {
+      const { app } = TestAdmin.setup({ zones: [TestEarn.zone] })
+      const response = await app.request('/earn/verified-vaults', {
+        body: JSON.stringify({ ...zoneInput, vaultAddress }),
+        headers: { 'content-type': 'application/json' },
+        method: 'PUT',
+      })
+      expect(response.status).toBe(409)
+      expect(await response.json()).toEqual(
+        expect.objectContaining({
+          error: expect.objectContaining({
+            code: 'earn_vault_verification_failed',
+            details: expect.arrayContaining([
+              { message: 'Earn router is configured for a different Earn vault.' },
+            ]),
+          }),
+        }),
+      )
+    },
+    60_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'verifies, stores, and preserves a Zone route',
+    async () => {
+      const { app, db } = TestAdmin.setup({ zones: [TestEarn.zone] })
+      const response = await app.request('/earn/verified-vaults', {
+        body: JSON.stringify(zoneInput),
+        headers: { 'content-type': 'application/json' },
+        method: 'PUT',
+      })
+      expect(response.status).toBe(200)
+      const vault = await TestApp.json(response, App.schema.putVerifiedEarnVault.Response)
+      expect(vault.capabilities).toMatchObject({ privateRouting: true, routerSwaps: true })
+      expect(vault.zones).toHaveLength(1)
+      expect(vault.zones?.[0]).toMatchObject(TestEarn.zoneRoute)
+      expect(vault.zone).toStrictEqual(
+        vault.zones?.[0]
+          ? {
+              chainId: vault.zones[0].chainId,
+              inputTokens: vault.zones[0].inputTokens,
+              name: vault.zones[0].name,
+              outputTokens: vault.zones[0].outputTokens,
+            }
+          : null,
+      )
+      expect(vault.zones?.[0]?.inputTokens).toHaveLength(1)
+      expect(vault.zones?.[0]?.outputTokens).toStrictEqual(vault.zones?.[0]?.inputTokens)
+
+      const updatedResponse = await app.request('/earn/verified-vaults', {
+        body: JSON.stringify({
+          chainId: zoneInput.chainId,
+          label: 'Updated Moderato Earn',
+          vaultAddress: zoneInput.vaultAddress,
+        }),
+        headers: { 'content-type': 'application/json' },
+        method: 'PUT',
+      })
+      expect(updatedResponse.status).toBe(200)
+      expect(
+        (await TestApp.json(updatedResponse, App.schema.putVerifiedEarnVault.Response)).zones,
+      ).toStrictEqual(vault.zones)
+      expect(
+        await core_EarnVaults.get(db, {
+          chainId: zoneInput.chainId,
+          vaultAddress: zoneInput.vaultAddress,
+        }),
+      ).toMatchObject({ zones: [TestEarn.zoneRoute] })
+    },
+    90_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'migrates preserved private tokens to a verified Zone route',
+    async () => {
+      const { app, db } = TestAdmin.setup({ zones: [TestEarn.zone] })
+      await core_EarnVaults.upsert(db, {
+        ...TestEarn.zoneVerifiedVault,
+        privateInputTokens: [asset],
+        privateOutputTokens: [asset],
+        zones: [],
+      })
+      const response = await app.request('/earn/verified-vaults', {
+        body: JSON.stringify({
+          chainId: zoneInput.chainId,
+          vaultAddress: zoneInput.vaultAddress,
+          zones: zoneInput.zones,
+        }),
+        headers: { 'content-type': 'application/json' },
+        method: 'PUT',
+      })
+
+      expect(response.status).toBe(200)
+      const vault = await TestApp.json(response, App.schema.putVerifiedEarnVault.Response)
+      expect(vault.zones).toHaveLength(1)
+      expect(
+        await core_EarnVaults.get(db, {
+          chainId: zoneInput.chainId,
+          vaultAddress: zoneInput.vaultAddress,
+        }),
+      ).toMatchObject({
+        privateInputTokens: [asset],
+        privateOutputTokens: [asset],
+        zones: [TestEarn.zoneRoute],
+      })
+    },
+    90_000,
+  )
+
   test.runIf(Runtime.get().mode === 'testnet')(
     'rejects private tokens without a configured router',
     async () => {