tapimo 0.13.0 → 0.15.0

package/src/Client.test-d.ts

@@ -8,15 +8,14 @@ import * as Balances from './apps/data/routes/balances.js'
 import * as Billing from './apps/management/routes/billing.js'
 import * as Blocks from './apps/data/routes/blocks.js'
 import * as Earn from './apps/data/routes/earn.js'
-import type * as EarnRates from './internal/EarnRates.js'
 import * as Exchanges from './apps/data/routes/exchanges.js'
 import * as Faucet from './apps/management/routes/faucet.js'
 import * as FeeAmm from './apps/data/routes/fee-amm.js'
-import * as FundingChains from './apps/funding/routes/chains.js'
-import * as FundingDepositAddresses from './apps/funding/routes/deposit-addresses.js'
-import * as FundingQuotes from './apps/funding/routes/quotes.js'
-import * as FundingTransfers from './apps/funding/routes/transfers.js'
-import type * as FundingDepositAddress from './internal/funding/DepositAddress.js'
+import * as RoutesChains from './apps/routes/routes/chains.js'
+import * as RoutesDepositAddresses from './apps/routes/routes/deposit-addresses.js'
+import * as RoutesQuotes from './apps/routes/routes/quotes.js'
+import * as RoutesTransfers from './apps/routes/routes/transfers.js'
+import type * as RoutesDepositAddress from './internal/routes/DepositAddress.js'
 import * as Indexer from './apps/data/routes/indexer.js'
 import * as InviteLinks from './apps/management/routes/invite-links.js'
 import * as Me from './apps/management/routes/me.js'
@@ -26,6 +25,7 @@ import * as OrgWebhooks from './apps/management/routes/webhooks.js'
 import * as Receipts from './apps/data/routes/receipts.js'
 import * as Rpc from './apps/data/routes/rpc.js'
 import * as Scopes from './apps/management/routes/scopes.js'
+import * as Tokenlist from './apps/data/routes/tokenlist.js'
 import * as Tokens from './apps/data/routes/tokens.js'
 import * as Transactions from './apps/data/routes/transactions.js'
 import * as Transfers from './apps/data/routes/transfers.js'
@@ -83,6 +83,57 @@ test('returns typed client', async () => {
 })
 
 describe('narrows responses by status', () => {
+  test('POST /v1/earn/rewards/eligibility', async () => {
+    const client = Client.create()
+    const res = await client.v1.earn.rewards.eligibility.$post({
+      json: {
+        chainId: 4217,
+        vaultAddress: `0x${'11'.repeat(20)}`,
+        walletAddress: `0x${'22'.repeat(20)}`,
+      },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json).toEqualTypeOf<
+          z.output<typeof Earn.schema.registerRewardEligibility.Response>
+        >()
+        expectTypeOf(json.created).toEqualTypeOf<boolean>()
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'api_key_ip_forbidden'>()
+        return
+      }
+    }
+  })
+
+  test('GET /v1/earn/rewards/eligibility', async () => {
+    const client = Client.create()
+    const res = await client.v1.earn.rewards.eligibility.$get({
+      query: {
+        chainId: '4217',
+        limit: '10',
+        vaultAddress: `0x${'11'.repeat(20)}`,
+      },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | PublicAccessStatus>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getRewardEligibility.Response>>()
+      expectTypeOf(json.chainId).toEqualTypeOf<number>()
+      expectTypeOf(json.data).toEqualTypeOf<`0x${string}`[]>()
+      expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
+      expectTypeOf(json.vaultAddress).toEqualTypeOf<`0x${string}`>()
+    }
+  })
+
   test('POST /v1/orgs/:orgId/projects/:projectId/api-keys/:keyId/rotate', async () => {
     const client = Client.create()
     const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
@@ -91,7 +142,7 @@ describe('narrows responses by status', () => {
       param: { keyId: 'key_test', orgId: 'org_test', projectId: 'prj_test' },
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 409 | 502>()
 
     if (res.status === 200) {
       const json = await res.json()
@@ -105,7 +156,7 @@ describe('narrows responses by status', () => {
       ':keyId{key_[A-Za-z0-9_-]+}'
     ].rotate.$post({ param: { keyId: 'key_test', orgId: 'org_test' } })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 409 | 502>()
 
     if (res.status === 200) {
       const json = await res.json()
@@ -229,11 +280,11 @@ describe('narrows responses by status', () => {
       expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getEarnVaults.Response>>()
       expectTypeOf(json.data[0]!.access?.status).toEqualTypeOf<'allowlisted' | 'open' | undefined>()
       // `apy` and `tvl` are include-gated, so both are absent unless requested.
-      expectTypeOf(json.data[0]!.apy).toEqualTypeOf<EarnRates.Apy | null | undefined>()
       expectTypeOf(json.data[0]!.apy?.methodology).toEqualTypeOf<
         'share-price-growth-annualized:v1' | undefined
       >()
       expectTypeOf(json.data[0]!.apy?.net).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.data[0]!.apy?.vault).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.data[0]!.apy?.window).toEqualTypeOf<
         '1h' | '1d' | '7d' | '30d' | undefined
       >()
@@ -241,7 +292,20 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.capabilities?.deposit).toEqualTypeOf<boolean | undefined>()
       expectTypeOf(json.data[0]!.engine.type).toEqualTypeOf<'erc4626' | 'veda' | null>()
       expectTypeOf(json.data[0]!.instantLiquidity).toEqualTypeOf<string | null>()
+      expectTypeOf(json.data[0]!.instantLiquidityValue).toEqualTypeOf<
+        VaultValue | null | undefined
+      >()
       expectTypeOf(json.data[0]!.sharePrice?.amount).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.data[0]!.apy?.rewards?.[0]?.apr).toEqualTypeOf<string | null | undefined>()
+      expectTypeOf(json.data[0]!.apy?.rewards?.[0]?.asset.address).toEqualTypeOf<
+        `0x${string}` | undefined
+      >()
+      expectTypeOf(json.data[0]!.apy?.rewards?.[0]?.calculatedThrough).toEqualTypeOf<
+        number | undefined
+      >()
+      expectTypeOf(json.data[0]!.apy?.rewards?.[0]?.targetTotalApr).toEqualTypeOf<
+        string | undefined
+      >()
       expectTypeOf(json.data[0]!.slug).toEqualTypeOf<string | null>()
       expectTypeOf(json.data[0]!.state.openRedeemRequestCount).toEqualTypeOf<number>()
       expectTypeOf(json.data[0]!.state.totalAssets).toEqualTypeOf<string>()
@@ -258,7 +322,9 @@ describe('narrows responses by status', () => {
     }
     if (res.status === 400) {
       const json = await res.json()
-      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        Access400<'chain_id_invalid' | 'chain_id_unsupported' | 'query_invalid'>
+      >()
       void json
       return
     }
@@ -286,6 +352,7 @@ describe('narrows responses by status', () => {
       expectTypeOf(json).toEqualTypeOf<
         z.output<typeof Earn.schema.getVerifiedEarnVaults.Response>
       >()
+      expectTypeOf(json.data[0]!.apy?.vault).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.data[0]!.engine.type).toEqualTypeOf<'erc4626' | 'veda'>()
       expectTypeOf(json.data[0]!.instantLiquidity).toEqualTypeOf<string | null>()
       expectTypeOf(json.data[0]!.slug).toEqualTypeOf<string>()
@@ -300,7 +367,9 @@ describe('narrows responses by status', () => {
     }
     if (res.status === 400) {
       const json = await res.json()
-      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        Access400<'chain_id_invalid' | 'chain_id_unsupported' | 'query_invalid'>
+      >()
       void json
       return
     }
@@ -316,7 +385,7 @@ describe('narrows responses by status', () => {
     const client = Client.create()
     const res = await client.v1.earn.addresses[':address'].positions.$get({
       param: { address: `0x${'bb'.repeat(20)}` },
-      query: { 'valuation.currency': 'USD', verified: 'true' },
+      query: { include: 'earnings', 'valuation.currency': 'USD', verified: 'true' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
@@ -330,7 +399,15 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.assetAmount.currency).toEqualTypeOf<string>()
       expectTypeOf(json.data[0]!.assetToken.address).toEqualTypeOf<`0x${string}`>()
       expectTypeOf(json.data[0]!.assetToken.decimals).toEqualTypeOf<number>()
+      expectTypeOf(json.data[0]!.chainId).toEqualTypeOf<number>()
       expectTypeOf(json.data[0]!.id).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.data[0]!.lifetimeCashFlows?.status).toEqualTypeOf<
+        'complete' | 'incomplete_history' | undefined
+      >()
+      if (json.data[0]!.lifetimeCashFlows?.status === 'complete') {
+        expectTypeOf(json.data[0]!.lifetimeCashFlows.totalDeposited).toEqualTypeOf<string>()
+        expectTypeOf(json.data[0]!.lifetimeCashFlows.totalWithdrawn).toEqualTypeOf<string>()
+      }
       expectTypeOf(json.data[0]!.shareAmount.amount).toEqualTypeOf<string>()
       expectTypeOf(json.data[0]!.shareAmount.decimals).toEqualTypeOf<number>()
       expectTypeOf(json.data[0]!.shareAmount.formatted).toEqualTypeOf<string>()
@@ -376,11 +453,13 @@ describe('narrows responses by status', () => {
       const json = await res.json()
       expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getEarnVault.Response>>()
       // `apy` and `tvl` are include-gated, so both are absent unless requested.
-      expectTypeOf(json.apy).toEqualTypeOf<EarnRates.Apy | null | undefined>()
       expectTypeOf(json.apy?.asOf).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.apy?.net).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.apy?.vault).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.assetToken.address).toEqualTypeOf<`0x${string}`>()
       expectTypeOf(json.engine.type).toEqualTypeOf<'erc4626' | 'veda' | null>()
       expectTypeOf(json.instantLiquidity).toEqualTypeOf<string | null>()
+      expectTypeOf(json.instantLiquidityValue).toEqualTypeOf<VaultValue | null | undefined>()
       expectTypeOf(json.label).toEqualTypeOf<string>()
       expectTypeOf(json.meta?.valuation?.asOf).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.sharePrice?.decimals).toEqualTypeOf<number | undefined>()
@@ -394,7 +473,58 @@ describe('narrows responses by status', () => {
     }
     if (res.status === 400) {
       const json = await res.json()
-      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid' | 'vault_id_invalid'>>()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        Access400<
+          'chain_id_invalid' | 'chain_id_unsupported' | 'query_invalid' | 'vault_id_invalid'
+        >
+      >()
+      void json
+      return
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'earn_vault_not_found'>()
+      void json
+      return
+    }
+    if (res.status === 502) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+      void json
+      return
+    }
+  })
+
+  test('GET /v1/earn/vaults/:vaultId/share-prices', async () => {
+    const client = Client.create()
+    const res = await client.v1.earn.vaults[':vaultId']['share-prices'].$get({
+      param: { vaultId: `0x${'aa'.repeat(20)}` },
+      query: {
+        from: '2026-07-01T00:00:00.000Z',
+        to: '2026-07-31T00:00:00.000Z',
+      },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<
+        z.output<typeof Earn.schema.getEarnVaultSharePrices.Response>
+      >()
+      expectTypeOf(json.data[0]!.sharePrice.amount).toEqualTypeOf<string>()
+      expectTypeOf(json.data[0]!.sharePrice.decimals).toEqualTypeOf<number>()
+      expectTypeOf(json.data[0]!.timestamp).toEqualTypeOf<string>()
+      void json
+      return
+    }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        Access400<
+          'chain_id_invalid' | 'chain_id_unsupported' | 'query_invalid' | 'vault_id_invalid'
+        >
+      >()
       void json
       return
     }
@@ -419,6 +549,7 @@ describe('narrows responses by status', () => {
         address: `0x${'bb'.repeat(20)}`,
         vaultId: `0x${'aa'.repeat(20)}`,
       },
+      query: { asOf: '2026-07-21T09:00:00.000Z' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
@@ -427,9 +558,23 @@ describe('narrows responses by status', () => {
       const json = await res.json()
       expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getEarnVaultPosition.Response>>()
       expectTypeOf(json.account).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.apy?.breakdown[0]?.assetAmount.baseUnits).toEqualTypeOf<
+        string | undefined
+      >()
+      expectTypeOf(json.apy?.breakdown[0]?.assetAmount.decimals).toEqualTypeOf<number | undefined>()
+      expectTypeOf(json.apy?.breakdown[0]?.assetAmount.formatted).toEqualTypeOf<
+        string | undefined
+      >()
+      expectTypeOf(json.apy?.breakdown[0]?.net).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.apy?.breakdown[0]?.type).toEqualTypeOf<'base' | 'boost' | undefined>()
+      expectTypeOf(json.apy?.net).toEqualTypeOf<string | undefined>()
       expectTypeOf(json.assetAllowance).toEqualTypeOf<string>()
       expectTypeOf(json.assetBalance).toEqualTypeOf<string>()
       expectTypeOf(json.assetToken).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.asOf).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.block?.number).toEqualTypeOf<number | undefined>()
+      expectTypeOf(json.block?.timestamp).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.chainId).toEqualTypeOf<number>()
       expectTypeOf(json.id).toEqualTypeOf<`0x${string}`>()
       expectTypeOf(json.shareAllowance).toEqualTypeOf<string>()
       expectTypeOf(json.shareBalance).toEqualTypeOf<string>()
@@ -462,6 +607,58 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('GET /v1/earn/vaults/:vaultId/positions/:address with reward proof', async () => {
+    const client = Client.create()
+    const res = await client.v1.earn.vaults[':vaultId'].positions[':address'].$get({
+      param: {
+        address: `0x${'bb'.repeat(20)}`,
+        vaultId: `0x${'aa'.repeat(20)}`,
+      },
+      query: { include: ['rewards.proof'] },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getEarnVaultPosition.Response>>()
+      expectTypeOf(json.rewards?.cumulativeEntitlement).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.rewards?.cumulativePaid).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.rewards?.pending).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.rewards?.proof?.cumulativeAmount).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.rewards?.proof?.distributorAddress).toEqualTypeOf<
+        `0x${string}` | undefined
+      >()
+      expectTypeOf(json.rewards?.proof?.proof).toEqualTypeOf<`0x${string}`[] | undefined>()
+      expectTypeOf(json.rewards?.proof?.rootVersion).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.rewards?.proof?.statementHash).toEqualTypeOf<`0x${string}` | undefined>()
+      void json
+      return
+    }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        Access400<
+          'chain_id_invalid' | 'chain_id_unsupported' | 'position_invalid' | 'query_invalid'
+        >
+      >()
+      void json
+      return
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'earn_vault_not_found'>()
+      void json
+      return
+    }
+    if (res.status === 502) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+      void json
+      return
+    }
+  })
+
   test('GET /v1/earn/vaults/:vaultId/earnings/:address', async () => {
     const client = Client.create()
     const res = await client.v1.earn.vaults[':vaultId'].earnings[':address'].$get({
@@ -487,7 +684,23 @@ describe('narrows responses by status', () => {
       if (json.status === 'complete' && json.period === 'active')
         expectTypeOf(json.activeEarnings).toEqualTypeOf<string>()
       if (json.status === 'complete' && json.period === 'lifetime')
-        expectTypeOf(json.lifetimeEarnings).toEqualTypeOf<string>()
+        expectTypeOf({
+          lifetimeEarnings: json.lifetimeEarnings,
+          totalDeposited: json.totalDeposited,
+          totalWithdrawn: json.totalWithdrawn,
+        }).toEqualTypeOf<{
+          lifetimeEarnings: string
+          totalDeposited: string
+          totalWithdrawn: string
+        }>()
+      if (json.status === 'pending_redemption' && json.period === 'lifetime')
+        expectTypeOf({
+          totalDeposited: json.totalDeposited,
+          totalWithdrawn: json.totalWithdrawn,
+        }).toEqualTypeOf<{
+          totalDeposited: string
+          totalWithdrawn: string
+        }>()
       if (json.status === 'complete' && json.period === '30d')
         expectTypeOf(json.windowEarnings).toEqualTypeOf<string>()
       void json
@@ -699,6 +912,42 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('GET /v1/orgs/:orgId/billing/invoice-preview', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing['invoice-preview'].$get({
+      param: { orgId: 'org_test' },
+    })
+    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 501 | 502 | PublicAccessStatus>()
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<z.output<typeof Billing.schema.InvoicePreview>>()
+      if (json.status === 'ready') {
+        expectTypeOf(json.lineItems[0]!.amount).toEqualTypeOf<string>()
+        expectTypeOf(json.lineItems[0]!.description).toEqualTypeOf<string>()
+        expectTypeOf(json.lineItems[0]!.kind).toEqualTypeOf<
+          'apiRequests' | 'feePayerSpend' | 'routeSubsidy' | null
+        >()
+        expectTypeOf(json.lineItems[0]!.period).toEqualTypeOf<{ end: string; start: string }>()
+        expectTypeOf(json.lineItems[0]!.priceId).toEqualTypeOf<string | null>()
+        expectTypeOf(json.lineItems[0]!.product).toEqualTypeOf<{
+          id: string
+          name: string
+        } | null>()
+        expectTypeOf(json.lineItems[0]!.quantity).toEqualTypeOf<number | null>()
+        expectTypeOf(json.lineItems[0]!.unitAmount).toEqualTypeOf<string | null>()
+        expectTypeOf(json.billingCredits).toEqualTypeOf<string>()
+        expectTypeOf(json.exclusiveTax).toEqualTypeOf<string>()
+        expectTypeOf(json.startingBalance).toEqualTypeOf<string>()
+        expectTypeOf(json.total).toEqualTypeOf<string>()
+        expectTypeOf(json.currency).toEqualTypeOf<'usd'>()
+      }
+    }
+    if (res.status === 501) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'billing_unconfigured'>()
+    }
+  })
+
   test('PATCH /v1/orgs/:orgId/billing', async () => {
     const client = Client.create()
     const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing.$patch({
@@ -857,7 +1106,9 @@ describe('narrows responses by status', () => {
       }
       case 409: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'sponsorships_unreported'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'routes_deposit_addresses_active' | 'sponsorships_unreported'
+        >()
         void json
         return
       }
@@ -1055,7 +1306,9 @@ describe('narrows responses by status', () => {
       }
       case 409: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'sponsorships_unreported'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'routes_deposit_addresses_active' | 'sponsorships_unreported'
+        >()
         void json
         return
       }
@@ -1071,7 +1324,7 @@ describe('narrows responses by status', () => {
       param: { orgId: 'org_test', projectId: 'prj_test' },
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 409 | 502>()
 
     switch (res.status) {
       case 200: {
@@ -1095,7 +1348,7 @@ describe('narrows responses by status', () => {
     const client = Client.create()
     const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['api-keys'].$get({
       // The environment filter is optional (defaults to production server-side).
-      query: { environment: 'sandbox' },
+      query: { environment: 'sandbox', include: '' },
       param: { orgId: 'org_test' },
     })
 
@@ -1329,6 +1582,12 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 429: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'payment_required' | 'rate_limit_exceeded'>()
+        void json
+        return
+      }
     }
   })
 
@@ -2227,10 +2486,12 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('GET /v1/funding/quotes', async () => {
+  test('GET /v1/routes/quotes', async () => {
     const client = Client.create()
-    const res = await client.v1.funding.quotes.$get({
+    const res = await client.v1.routes.quotes.$get({
       query: {
+        destinationChain: 'eip155:8453',
+        destinationToken: 'USDC',
         provider: 'across',
         sourceAmount: '1000000',
         sourceChain: 'base',
@@ -2259,14 +2520,16 @@ describe('narrows responses by status', () => {
           | undefined
         >()
         expectTypeOf(json.data[0]!.sourceAmount).toEqualTypeOf<
-          z.output<
-            typeof FundingQuotes.schema.quoteFunding.Response
-          >['data'][number]['sourceAmount']
+          z.output<typeof RoutesQuotes.schema.quoteRoutes.Response>['data'][number]['sourceAmount']
         >()
         // @ts-expect-error token references do not contain quantities
         void json.data[0]!.sourceToken.amount
         // @ts-expect-error provider details no longer duplicate destination amounts
         void json.data[0]!.quote.outputAmount
+        // @ts-expect-error provider liquidity sources are private implementation details
+        void json.data[0]!.quality.liquiditySource
+        // @ts-expect-error provider endpoint details are private implementation details
+        void json.data[0]!.quality.sourceDetail
         expectTypeOf(json.data[0]!.provider.id).toEqualTypeOf<string>()
         expectTypeOf(json.data[0]!.quote.expiresAt).toEqualTypeOf<string | undefined>()
         expectTypeOf(json.data[0]!.destinationChain.addressFormat).toEqualTypeOf<
@@ -2295,9 +2558,9 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('GET /v1/funding/chains', async () => {
+  test('GET /v1/routes/chains', async () => {
     const client = Client.create()
-    const res = await client.v1.funding.chains.$get()
+    const res = await client.v1.routes.chains.$get()
 
     expectTypeOf(res.status).toEqualTypeOf<200 | PaidAccessStatus>()
 
@@ -2306,7 +2569,7 @@ describe('narrows responses by status', () => {
         const json = await res.json()
         expectTypeOf(json.data[0]!.tokens[0]!.symbol).toEqualTypeOf<
           z.output<
-            typeof FundingChains.schema.getFundingChains.Response
+            typeof RoutesChains.schema.getRoutesChains.Response
           >['data'][number]['tokens'][number]['symbol']
         >()
         expectTypeOf(json.data[0]!.addressFormat).toEqualTypeOf<'base58' | 'base58check' | 'hex'>()
@@ -2323,9 +2586,9 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('GET /v1/funding/providers', async () => {
+  test('GET /v1/routes/providers', async () => {
     const client = Client.create()
-    const res = await client.v1.funding.providers.$get()
+    const res = await client.v1.routes.providers.$get()
 
     expectTypeOf(res.status).toEqualTypeOf<200 | PaidAccessStatus>()
 
@@ -2348,7 +2611,7 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('POST /v1/funding/deposit-addresses', async () => {
+  test('POST /v1/routes/deposit-addresses', async () => {
     const client = Client.create()
     const json = {
       amount: '100000000',
@@ -2359,13 +2622,13 @@ describe('narrows responses by status', () => {
       sourceToken: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
     } as const
     // @ts-expect-error `Idempotency-Key` is required for deposit-address creation.
-    void client.v1.funding['deposit-addresses'].$post({ json })
-    const res = await client.v1.funding['deposit-addresses'].$post({
-      header: { 'idempotency-key': 'funding_01k1c5j8q8p0be6j5v9m6d1e4r' },
+    void client.v1.routes['deposit-addresses'].$post({ json })
+    const res = await client.v1.routes['deposit-addresses'].$post({
+      header: { 'idempotency-key': 'routes_01k1c5j8q8p0be6j5v9m6d1e4r' },
       json,
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PublicAccessStatus>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 403 | 404 | 409 | 502 | PublicAccessStatus>()
 
     switch (res.status) {
       case 200: {
@@ -2373,14 +2636,14 @@ describe('narrows responses by status', () => {
         expectTypeOf(json.id).toEqualTypeOf<string>()
         expectTypeOf(json.status).toEqualTypeOf<
           z.output<
-            typeof FundingDepositAddresses.schema.createFundingDepositAddress.Response
+            typeof RoutesDepositAddresses.schema.createRoutesDepositAddress.Response
           >['status']
         >()
         expectTypeOf(json.subsidize).toEqualTypeOf<boolean>()
         if ('quote' in json) {
           expectTypeOf(json.destinationAmount.baseUnits).toEqualTypeOf<string>()
           expectTypeOf(json.fees).toEqualTypeOf<
-            z.output<typeof FundingDepositAddress.schema.CreatedFundingDepositAddress>['fees']
+            z.output<typeof RoutesDepositAddress.schema.CreatedRoutesDepositAddress>['fees']
           >()
           expectTypeOf(json.quote.sampledAt).toEqualTypeOf<string>()
           expectTypeOf(json.sourceAmount.baseUnits).toEqualTypeOf<string>()
@@ -2388,6 +2651,19 @@ 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'
+          | 'billing_past_due'
+          | 'billing_required'
+          | 'routes_deposit_address_limit_exceeded'
+          | 'routes_subsidy_not_enabled'
+        >()
+        void json
+        return
+      }
       case 404: {
         const json = await res.json()
         expectTypeOf(json.error.code).toEqualTypeOf<'deposit_address_not_available'>()
@@ -2405,10 +2681,10 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('GET /v1/funding/deposit-addresses/:id', async () => {
+  test('GET /v1/routes/deposit-addresses/:id', async () => {
     const client = Client.create()
-    const res = await client.v1.funding['deposit-addresses'][':id{fda_[A-Za-z0-9_-]+}'].$get({
-      param: { id: 'fda_test' },
+    const res = await client.v1.routes['deposit-addresses'][':id{rda_[A-Za-z0-9_-]+}'].$get({
+      param: { id: 'rda_test' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()
@@ -2417,7 +2693,7 @@ describe('narrows responses by status', () => {
       case 200: {
         const json = await res.json()
         expectTypeOf(json.status).toEqualTypeOf<
-          z.output<typeof FundingDepositAddresses.schema.DepositAddress>['status']
+          z.output<typeof RoutesDepositAddresses.schema.DepositAddress>['status']
         >()
         expectTypeOf(json.sourceChain.kind).toEqualTypeOf<'evm' | 'solana' | 'tron'>()
         expectTypeOf(json.subsidize).toEqualTypeOf<boolean>()
@@ -2428,16 +2704,16 @@ describe('narrows responses by status', () => {
       }
       case 404: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_found'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<'routes_deposit_address_not_found'>()
         void json
         return
       }
     }
   })
 
-  test('GET /v1/funding/deposit-addresses', async () => {
+  test('GET /v1/routes/deposit-addresses', async () => {
     const client = Client.create()
-    const res = await client.v1.funding['deposit-addresses'].$get()
+    const res = await client.v1.routes['deposit-addresses'].$get()
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PublicAccessStatus>()
 
@@ -2445,7 +2721,7 @@ describe('narrows responses by status', () => {
       case 200: {
         const json = await res.json()
         expectTypeOf(json.data[0]!.status).toEqualTypeOf<
-          z.output<typeof FundingDepositAddresses.schema.DepositAddress>['status']
+          z.output<typeof RoutesDepositAddresses.schema.DepositAddress>['status']
         >()
         expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
         void json
@@ -2454,11 +2730,11 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('POST /v1/funding/deposit-addresses/:id/reconcile', async () => {
+  test('POST /v1/routes/deposit-addresses/:id/reconcile', async () => {
     const client = Client.create()
-    const res = await client.v1.funding['deposit-addresses'][
-      ':id{fda_[A-Za-z0-9_-]+}'
-    ].reconcile.$post({ param: { id: 'fda_test' } })
+    const res = await client.v1.routes['deposit-addresses'][
+      ':id{rda_[A-Za-z0-9_-]+}'
+    ].reconcile.$post({ param: { id: 'rda_test' } })
 
     expectTypeOf(res.status).toEqualTypeOf<202 | 400 | 401 | 403 | 404 | 409 | 429 | 501 | 502>()
 
@@ -2469,13 +2745,13 @@ describe('narrows responses by status', () => {
       }
       case 404: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_found'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<'routes_deposit_address_not_found'>()
         void json
         return
       }
       case 409: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_active'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<'routes_deposit_address_not_active'>()
         void json
         return
       }
@@ -2494,13 +2770,13 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('GET /v1/funding/deposits', async () => {
+  test('GET /v1/routes/deposits', async () => {
     const client = Client.create()
-    void client.v1.funding.deposits.$get()
-    void client.v1.funding.deposits.$get({
+    void client.v1.routes.deposits.$get()
+    void client.v1.routes.deposits.$get({
       query: { depositAddress: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8' },
     })
-    const res = await client.v1.funding.deposits.$get({
+    const res = await client.v1.routes.deposits.$get({
       query: {
         depositAddress: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
         destinationToken: 'usdt0',
@@ -2520,10 +2796,10 @@ describe('narrows responses by status', () => {
         const json = await res.json()
         expectTypeOf(json.data[0]!.recipient).toEqualTypeOf<string>()
         expectTypeOf(json.data[0]!.status).toEqualTypeOf<
-          z.output<typeof FundingDepositAddresses.schema.Deposit>['status']
+          z.output<typeof RoutesDepositAddresses.schema.Deposit>['status']
         >()
         expectTypeOf(json.meta).toEqualTypeOf<
-          z.output<typeof FundingDepositAddresses.schema.listFundingDeposits.Response>['meta']
+          z.output<typeof RoutesDepositAddresses.schema.listRoutesDeposits.Response>['meta']
         >()
         expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
         void json
@@ -2532,10 +2808,10 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('GET /v1/funding/deposits/:id', async () => {
+  test('GET /v1/routes/deposits/:id', async () => {
     const client = Client.create()
-    const res = await client.v1.funding.deposits[':id{fdp_[A-Za-z0-9_-]+}'].$get({
-      param: { id: 'fdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx' },
+    const res = await client.v1.routes.deposits[':id{rdp_[A-Za-z0-9_-]+}'].$get({
+      param: { id: 'rdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()
@@ -2547,11 +2823,11 @@ describe('narrows responses by status', () => {
           'chain' | 'manual' | 'poll' | 'webhook' | undefined
         >()
         expectTypeOf(json.destinationAmountRequired).toEqualTypeOf<
-          z.output<typeof FundingDepositAddresses.schema.Deposit>['destinationAmountRequired']
+          z.output<typeof RoutesDepositAddresses.schema.Deposit>['destinationAmountRequired']
         >()
         expectTypeOf(json.sourceTransferIndex).toEqualTypeOf<number | undefined>()
         expectTypeOf(json.statusReason).toEqualTypeOf<
-          z.output<typeof FundingDepositAddresses.schema.Deposit>['statusReason']
+          z.output<typeof RoutesDepositAddresses.schema.Deposit>['statusReason']
         >()
         // @ts-expect-error provider request identifiers remain private
         void json.providerRequestIds
@@ -2560,16 +2836,16 @@ describe('narrows responses by status', () => {
       }
       case 404: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_not_found'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<'routes_deposit_not_found'>()
         void json
         return
       }
     }
   })
 
-  test('GET /v1/funding/transfers', async () => {
+  test('GET /v1/routes/transfers', async () => {
     const client = Client.create()
-    const res = await client.v1.funding.transfers.$get({ query: {} })
+    const res = await client.v1.routes.transfers.$get({ query: {} })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PublicAccessStatus>()
 
@@ -2578,7 +2854,7 @@ describe('narrows responses by status', () => {
         const json = await res.json()
         expectTypeOf(json.data[0]!.id).toEqualTypeOf<string>()
         expectTypeOf(json.data[0]!.status).toEqualTypeOf<
-          z.output<typeof FundingTransfers.schema.Transfer>['status']
+          z.output<typeof RoutesTransfers.schema.Transfer>['status']
         >()
         expectTypeOf(json.data[0]!.version).toEqualTypeOf<number>()
         // Transfer reads never expose the executable action.
@@ -2586,7 +2862,7 @@ describe('narrows responses by status', () => {
         void json.data[0]!.action
         // `meta` (opt-in `include=totalCount` count) is optional.
         expectTypeOf(json.meta).toEqualTypeOf<
-          z.output<typeof FundingTransfers.schema.listFundingTransfers.Response>['meta']
+          z.output<typeof RoutesTransfers.schema.listRoutesTransfers.Response>['meta']
         >()
         expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
         void json
@@ -2602,10 +2878,11 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('POST /v1/funding/transfers', async () => {
+  test('POST /v1/routes/transfers', async () => {
     const client = Client.create()
     const json = {
       amount: '1000000',
+      destinationChain: 'eip155:8453',
       destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
       mode: 'exactSource',
       provider: 'stargate',
@@ -2614,14 +2891,16 @@ describe('narrows responses by status', () => {
       sourceChain: 'eip155:8453',
       sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
     } as const
-    // @ts-expect-error `Idempotency-Key` is required for funding transfer creation.
-    void client.v1.funding.transfers.$post({ json })
-    const res = await client.v1.funding.transfers.$post({
-      header: { 'idempotency-key': 'funding_01k1c5j8q8p0be6j5v9m6d1e4r' },
+    // @ts-expect-error `Idempotency-Key` is required for route transfer creation.
+    void client.v1.routes.transfers.$post({ json })
+    const res = await client.v1.routes.transfers.$post({
+      header: { 'idempotency-key': 'routes_01k1c5j8q8p0be6j5v9m6d1e4r' },
       json,
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PublicAccessStatus>()
+    expectTypeOf(res.status).toEqualTypeOf<
+      200 | 400 | 403 | 404 | 409 | 501 | 502 | 503 | PublicAccessStatus
+    >()
 
     switch (res.status) {
       case 200: {
@@ -2629,7 +2908,7 @@ describe('narrows responses by status', () => {
         expectTypeOf(json.action.type).toEqualTypeOf<'evm:calls'>()
         expectTypeOf(json.id).toEqualTypeOf<string>()
         expectTypeOf(json.status).toEqualTypeOf<
-          z.output<typeof FundingTransfers.schema.createFundingTransfer.Response>['status']
+          z.output<typeof RoutesTransfers.schema.createRoutesTransfer.Response>['status']
         >()
         void json
         return
@@ -2651,7 +2930,7 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('POST /v1/funding/transfers/vault', async () => {
+  test('POST /v1/routes/transfers/vault', async () => {
     const client = Client.create()
     const json = {
       amount: '1000000',
@@ -2663,9 +2942,9 @@ describe('narrows responses by status', () => {
       vaultAddress: `0x${'f4'.repeat(20)}`,
     } as const
     // @ts-expect-error `Idempotency-Key` is required for vault transfer creation.
-    void client.v1.funding.transfers.vault.$post({ json })
-    const res = await client.v1.funding.transfers.vault.$post({
-      header: { 'idempotency-key': 'funding_vault_01k1c5j8q8p0be6j5v9m6d1e4r' },
+    void client.v1.routes.transfers.vault.$post({ json })
+    const res = await client.v1.routes.transfers.vault.$post({
+      header: { 'idempotency-key': 'routes_vault_01k1c5j8q8p0be6j5v9m6d1e4r' },
       json,
     })
 
@@ -2677,7 +2956,7 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('POST /v1/funding/transfers/zone', async () => {
+  test('POST /v1/routes/transfers/zone', async () => {
     const client = Client.create()
     const json = {
       amount: '1000000',
@@ -2691,9 +2970,9 @@ describe('narrows responses by status', () => {
       sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
     } as const
     // @ts-expect-error `Idempotency-Key` is required for Zone transfer creation.
-    void client.v1.funding.transfers.zone.$post({ json })
-    const res = await client.v1.funding.transfers.zone.$post({
-      header: { 'idempotency-key': 'funding_zone_01k1c5j8q8p0be6j5v9m6d1e4r' },
+    void client.v1.routes.transfers.zone.$post({ json })
+    const res = await client.v1.routes.transfers.zone.$post({
+      header: { 'idempotency-key': 'routes_zone_01k1c5j8q8p0be6j5v9m6d1e4r' },
       json,
     })
 
@@ -2705,10 +2984,10 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('GET /v1/funding/transfers/:id', async () => {
+  test('GET /v1/routes/transfers/:id', async () => {
     const client = Client.create()
-    const res = await client.v1.funding.transfers[':id{ftr_[A-Za-z0-9_-]+}'].$get({
-      param: { id: 'ftr_test' },
+    const res = await client.v1.routes.transfers[':id{rtr_[A-Za-z0-9_-]+}'].$get({
+      param: { id: 'rtr_test' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()
@@ -2718,10 +2997,10 @@ describe('narrows responses by status', () => {
         const json = await res.json()
         expectTypeOf(json.id).toEqualTypeOf<string>()
         expectTypeOf(json.status).toEqualTypeOf<
-          z.output<typeof FundingTransfers.schema.getFundingTransfer.Response>['status']
+          z.output<typeof RoutesTransfers.schema.getRoutesTransfer.Response>['status']
         >()
         expectTypeOf(json.statusReason).toEqualTypeOf<
-          z.output<typeof FundingTransfers.schema.getFundingTransfer.Response>['statusReason']
+          z.output<typeof RoutesTransfers.schema.getRoutesTransfer.Response>['statusReason']
         >()
         // @ts-expect-error `action` is a creation-only field
         void json.action
@@ -2730,7 +3009,7 @@ describe('narrows responses by status', () => {
       }
       case 404: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'funding_transfer_not_found'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<'routes_transfer_not_found'>()
         expectTypeOf(json.error.message).toEqualTypeOf<string>()
         void json
         return
@@ -2738,6 +3017,46 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('POST /v1/routes/transfers/:id/source-transactions', async () => {
+    const client = Client.create()
+    const sourceTransactions =
+      client.v1.routes.transfers[':id{rtr_[A-Za-z0-9_-]+}']['source-transactions']
+    const res = await sourceTransactions.$post({
+      json: { transactionHashes: [`0x${'51'.repeat(32)}`, `0x${'52'.repeat(32)}`] },
+      param: { id: 'rtr_test' },
+    })
+    void sourceTransactions.$post({
+      json: { transactionHash: `0x${'51'.repeat(32)}` },
+      param: { id: 'rtr_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 501 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.sourceTransactionHashes).toEqualTypeOf<string[] | undefined>()
+        expectTypeOf(json.status).toEqualTypeOf<
+          z.output<
+            typeof RoutesTransfers.schema.registerRoutesTransferSourceTransaction.Response
+          >['status']
+        >()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          | 'routes_transfer_not_awaiting_source'
+          | 'source_transaction_conflict'
+          | 'source_transaction_pending'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
   test('GET /v1/exchange/swaps', async () => {
     const client = Client.create()
     const res = await client.v1.exchange.swaps.$get()
@@ -3315,6 +3634,9 @@ describe('narrows responses by status', () => {
         expectTypeOf(json.data[0]!.address).toEqualTypeOf<
           z.output<typeof VerifiedTokens.schema.Token>['address']
         >()
+        expectTypeOf(json.data[0]!.id).toEqualTypeOf<
+          z.output<typeof VerifiedTokens.schema.Token>['id']
+        >()
         void json
         return
       }
@@ -3379,6 +3701,7 @@ describe('narrows responses by status', () => {
         expectTypeOf(json.address).toEqualTypeOf<
           z.output<typeof VerifiedTokens.schema.Token>['address']
         >()
+        expectTypeOf(json.id).toEqualTypeOf<z.output<typeof VerifiedTokens.schema.Token>['id']>()
         void json
         return
       }
@@ -3408,13 +3731,48 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('GET /v1/tokenlist', async () => {
+    const client = Client.create()
+    const res = await client.v1.tokenlist.$get({ query: {} })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.tokens[0]!.address).toEqualTypeOf<
+          z.output<typeof Tokenlist.schema.Token>['address']
+        >()
+        expectTypeOf(json.version).toEqualTypeOf<z.output<typeof Tokenlist.schema.Version>>()
+        void json
+        return
+      }
+      case 400: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          Access400<'chain_id_invalid' | 'chain_id_unsupported' | 'query_invalid'>
+        >()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 502: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
+    }
+  })
+
   test('GET /v1/indexer/query', async () => {
     const client = Client.create()
     const res = await client.v1.indexer.query.$get({
       query: { chainId: '42431', sql: 'select 1' },
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 422 | PaidAccessStatus>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 422 | 502 | 504 | PaidAccessStatus>()
 
     switch (res.status) {
       case 200: {
@@ -3435,7 +3793,9 @@ describe('narrows responses by status', () => {
           expectTypeOf(json.error).toEqualTypeOf<string>()
           expectTypeOf(json.ok).toEqualTypeOf<false>()
         } else {
-          expectTypeOf(json.error.code).toEqualTypeOf<'api_key_malformed'>()
+          expectTypeOf(json.error.code).toEqualTypeOf<
+            Access400<'chain_id_invalid' | 'chain_id_unsupported'>
+          >()
         }
         void json
         return
@@ -3447,6 +3807,37 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 502: {
+        const json = await res.json()
+        if ('ok' in json) {
+          expectTypeOf(json.error).toEqualTypeOf<string>()
+          expectTypeOf(json.ok).toEqualTypeOf<false>()
+        } else {
+          expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+          expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        }
+        void json
+        return
+      }
+      case 504: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'request_timeout'>()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/indexer/query?live=true', async () => {
+    const client = Client.create()
+    const res = await client.v1.indexer.query.$get({
+      query: { chainId: '42431', live: 'true', sql: 'select 1' },
+    })
+
+    if (res.status === 200) {
+      const text = await res.text()
+      expectTypeOf(text).toEqualTypeOf<string>()
     }
   })
 
@@ -3515,17 +3906,18 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('POST /rpc/:chain', async () => {
+  test('POST /rpc', async () => {
     const client = Client.create()
-    const res = await client.rpc[':chain{(mainnet|testnet|[0-9]+)}?'].$post({
-      param: { chain: undefined },
+    const res = await client.rpc.$post({
+      json: { jsonrpc: '2.0', method: 'eth_chainId', params: [] },
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | PublicAccessStatus>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 204 | 400 | 413 | 502 | PublicAccessStatus>()
 
     switch (res.status) {
       case 200: {
         const json = await res.json()
+        if (json === null) return
         if (Array.isArray(json))
           expectTypeOf(json[0]!.jsonrpc).toEqualTypeOf<
             z.output<typeof Rpc.schema.Response>['jsonrpc']
@@ -3537,27 +3929,44 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 204:
+        return
       case 400: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'chain_id_invalid'>>()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          Access400<'chain_id_invalid' | 'chain_id_unsupported'>
+        >()
         expectTypeOf(json.error.message).toEqualTypeOf<string>()
         void json
         return
       }
+      case 413: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'payload_too_large'>()
+        return
+      }
+      case 502: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+        void json
+        return
+      }
     }
   })
 
   test('POST /rpc/:chain testnet shortcut', async () => {
     const client = Client.create()
-    const res = await client.rpc[':chain{(mainnet|testnet|[0-9]+)}?'].$post({
+    const res = await client.rpc[':chain{(mainnet|testnet|[0-9]+)}'].$post({
+      json: { id: 1, jsonrpc: '2.0', method: 'eth_chainId', params: [] },
       param: { chain: 'testnet' },
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | PublicAccessStatus>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 204 | 400 | 413 | 502 | PublicAccessStatus>()
 
     switch (res.status) {
       case 200: {
         const json = await res.json()
+        if (json === null) return
         if (Array.isArray(json))
           expectTypeOf(json[0]!.jsonrpc).toEqualTypeOf<
             z.output<typeof Rpc.schema.Response>['jsonrpc']
@@ -3569,13 +3978,28 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 204:
+        return
       case 400: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'chain_id_invalid'>>()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          Access400<'chain_id_invalid' | 'chain_id_unsupported'>
+        >()
         expectTypeOf(json.error.message).toEqualTypeOf<string>()
         void json
         return
       }
+      case 413: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'payload_too_large'>()
+        return
+      }
+      case 502: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+        void json
+        return
+      }
     }
   })
 
@@ -3584,8 +4008,14 @@ describe('narrows responses by status', () => {
     const res = await client.v1.addresses[':address'].activities.$get({
       param: { address: '0x0000000000000000000000000000000000000000' },
       query: {
+        'amount.from': '1000000',
+        'amount.to': '2000000',
         chainId: '4217',
         include: 'zones,token.logoUri,token.verified',
+        type: 'transfer,swap',
+        'valuation.amount.from': '1',
+        'valuation.amount.to': '100',
+        'valuation.currency': 'USD',
       },
     })
 
@@ -3642,6 +4072,14 @@ describe('narrows responses by status', () => {
       expectTypeOf(json.data[0]!.type).toEqualTypeOf<Webhooks.EventType>()
       void json
     }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'api_key_malformed'>()
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'webhooks_not_enabled'>()
+    }
   })
 
   test('POST /v1/webhooks', async () => {
@@ -3649,14 +4087,24 @@ describe('narrows responses by status', () => {
     void client.v1.webhooks.$post({
       json: {
         destination: { type: 'url', url: 'https://example.com/webhook' },
-        eventType: 'funding:deposit.updated',
+        eventType: 'routes:deposit.updated',
         filters: {
-          depositAddressId: 'fda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
+          depositAddressId: 'rda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
           recipient: `0x${'11'.repeat(20)}`,
           status: 'completed',
         },
       },
     })
+    void client.v1.webhooks.$post({
+      json: {
+        destination: { type: 'url', url: 'https://example.com/webhook' },
+        eventType: 'routes:transfer.updated',
+        filters: {
+          id: 'rtr_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
+          status: 'completed',
+        },
+      },
+    })
     const res = await client.v1.webhooks.$post({
       json: {
         destination: { type: 'url', url: 'https://example.com/webhook' },
@@ -3697,6 +4145,10 @@ describe('narrows responses by status', () => {
         'api_key_forbidden' | 'api_key_ip_forbidden' | 'limit_exceeded'
       >()
     }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'webhooks_not_enabled'>()
+    }
   })
 
   test('GET /v1/webhooks', async () => {
@@ -3721,6 +4173,14 @@ describe('narrows responses by status', () => {
       >()
       void json
     }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'webhooks_not_enabled'>()
+    }
   })
 
   test('GET /v1/webhooks/:id', async () => {
@@ -3742,6 +4202,14 @@ describe('narrows responses by status', () => {
       >()
       void json
     }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'param_invalid'>>()
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'webhook_not_found' | 'webhooks_not_enabled'>()
+    }
   })
 
   test('GET /v1/webhooks/:id/deliveries', async () => {
@@ -3763,6 +4231,14 @@ describe('narrows responses by status', () => {
       >()
       void json
     }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'param_invalid' | 'query_invalid'>>()
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'webhook_not_found' | 'webhooks_not_enabled'>()
+    }
   })
 
   test('POST /v1/webhooks/:id/ping', async () => {
@@ -3780,6 +4256,14 @@ describe('narrows responses by status', () => {
       >()
       void json
     }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'param_invalid'>>()
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'webhook_not_found' | 'webhooks_not_enabled'>()
+    }
   })
 
   test('POST /v1/webhooks/:id/deliveries/:deliveryId/retry', async () => {
@@ -3799,6 +4283,16 @@ describe('narrows responses by status', () => {
       >()
       void json
     }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'param_invalid'>>()
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        'delivery_not_found' | 'webhook_not_found' | 'webhooks_not_enabled'
+      >()
+    }
   })
 
   test('PATCH /v1/webhooks/:id', async () => {
@@ -3833,6 +4327,10 @@ describe('narrows responses by status', () => {
         >
       >()
     }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'webhook_not_found' | 'webhooks_not_enabled'>()
+    }
   })
 
   test('DELETE /v1/webhooks/:id', async () => {
@@ -3850,6 +4348,14 @@ describe('narrows responses by status', () => {
       >()
       void json
     }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'param_invalid'>>()
+    }
+    if (res.status === 404) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'webhook_not_found' | 'webhooks_not_enabled'>()
+    }
   })
 
   test('POST /v1/orgs/:orgId/webhooks', async () => {
@@ -3944,9 +4450,13 @@ describe('narrows responses by status', () => {
       >()
       if (json.envelope.type === 'block:created')
         expectTypeOf(json.envelope.data.number).toEqualTypeOf<number>()
-      if (json.envelope.type === 'funding:deposit.updated')
+      if (json.envelope.type === 'routes:deposit.updated')
+        expectTypeOf(json.envelope.data.status).toEqualTypeOf<
+          z.output<typeof Webhooks.schema.RoutesDepositEvent>['status']
+        >()
+      if (json.envelope.type === 'routes:transfer.updated')
         expectTypeOf(json.envelope.data.status).toEqualTypeOf<
-          z.output<typeof Webhooks.schema.FundingDepositEvent>['status']
+          z.output<typeof Webhooks.schema.RoutesTransferEvent>['status']
         >()
       expectTypeOf(json.requestUrl).toEqualTypeOf<string>()
       void json