tapimo 0.7.1 → 0.8.0

package/src/Client.test-d.ts

@@ -6,10 +6,16 @@ import * as Activities from './apps/data/routes/activities.js'
 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 Funding from './apps/data/routes/funding.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 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,10 +32,13 @@ import * as Valuation from './apps/data/routes/valuation.js'
 import * as VerifiedTokenRequests from './apps/management/routes/verified-token-requests.js'
 import * as VerifiedTokens from './apps/data/routes/verified-tokens.js'
 import * as Webhooks from './apps/data/routes/webhooks.js'
+import * as Zones from './apps/data/routes/zones.js'
 
 type Access400<code extends string> = code | 'api_key_malformed'
 type PaidAccessStatus = PublicAccessStatus | 402
 type PublicAccessStatus = 400 | 401 | 403 | 429
+/** Wire shape of a valued Earn vault field. */
+type VaultValue = { amount: string; currency: string; decimals: number; formatted: string }
 const mppInput = {
   challenge: {
     description: 'Tempo API payment',
@@ -73,42 +82,30 @@ test('returns typed client', async () => {
 })
 
 describe('narrows responses by status', () => {
-  test('POST /v1/mpp/verify', async () => {
+  test('POST /v1/mpp/validate', async () => {
     const client = Client.create()
-    const res = await client.v1.mpp.verify.$post({ json: mppInput })
+    const res = await client.v1.mpp.validate.$post({ json: mppInput })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429 | 503>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429>()
 
     if (res.status === 200) {
       const json = await res.json()
       expectTypeOf(json).toEqualTypeOf<Mpp.VerifyResponse>()
       return
     }
-
-    if (res.status === 503) {
-      const json = await res.json()
-      expectTypeOf(json).toEqualTypeOf<Mpp.Unavailable>()
-      return
-    }
   })
 
   test('POST /v1/mpp/broadcast', async () => {
     const client = Client.create()
     const res = await client.v1.mpp.broadcast.$post({ json: mppInput })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429 | 503>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429>()
 
     if (res.status === 200) {
       const json = await res.json()
       expectTypeOf(json).toEqualTypeOf<Mpp.BroadcastResponse>()
       return
     }
-
-    if (res.status === 503) {
-      const json = await res.json()
-      expectTypeOf(json).toEqualTypeOf<Mpp.Unavailable>()
-      return
-    }
   })
 
   test('GET /v1/blocks', async () => {
@@ -147,7 +144,7 @@ describe('narrows responses by status', () => {
       }
       case 403: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'api_key_ip_forbidden'>()
         expectTypeOf(json.error.message).toEqualTypeOf<string>()
         void json
         return
@@ -169,6 +166,253 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('GET /v1/earn/vaults', async () => {
+    const client = Client.create()
+    const res = await client.v1.earn.vaults.$get({
+      query: {
+        'apy.window': '24h',
+        capability: 'deposit',
+        'engine.type': 'erc4626',
+        include: 'access,apy,capabilities,token.logoUri,tvl,zone',
+      },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      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?.window).toEqualTypeOf<
+        '1h' | '1d' | '7d' | '30d' | undefined
+      >()
+      expectTypeOf(json.data[0]!.assetToken.address).toEqualTypeOf<`0x${string}`>()
+      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]!.sharePrice?.amount).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>()
+      expectTypeOf(json.data[0]!.tvl).toEqualTypeOf<VaultValue | null | undefined>()
+      expectTypeOf(json.data[0]!.tvl?.currency).toEqualTypeOf<string | undefined>()
+      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.meta?.valuation?.basis).toEqualTypeOf<'nominal' | undefined>()
+      void json
+      return
+    }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
+      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/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' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<
+        z.output<typeof Earn.schema.getVerifiedEarnVaults.Response>
+      >()
+      expectTypeOf(json.data[0]!.engine.type).toEqualTypeOf<'erc4626' | 'veda'>()
+      expectTypeOf(json.data[0]!.instantLiquidity).toEqualTypeOf<string | null>()
+      expectTypeOf(json.data[0]!.slug).toEqualTypeOf<string>()
+      expectTypeOf(json.data[0]!.state.feesActive).toEqualTypeOf<boolean>()
+      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.meta?.valuation?.source).toEqualTypeOf<string | undefined>()
+      void json
+      return
+    }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
+      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', async () => {
+    const client = Client.create()
+    const res = await client.v1.earn.vaults[':vaultId'].$get({
+      param: { vaultId: `0x${'aa'.repeat(20)}` },
+      query: { 'apy.window': '1h', include: 'token.logoUri,tvl' },
+    })
+
+    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.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.assetToken.address).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.engine.type).toEqualTypeOf<'erc4626' | 'veda' | null>()
+      expectTypeOf(json.instantLiquidity).toEqualTypeOf<string | null>()
+      expectTypeOf(json.label).toEqualTypeOf<string>()
+      expectTypeOf(json.meta?.valuation?.asOf).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.sharePrice?.decimals).toEqualTypeOf<number | undefined>()
+      expectTypeOf(json.slug).toEqualTypeOf<string | null>()
+      expectTypeOf(json.state.depositsPaused).toEqualTypeOf<boolean>()
+      expectTypeOf(json.tvl).toEqualTypeOf<VaultValue | null | undefined>()
+      expectTypeOf(json.tvl?.amount).toEqualTypeOf<string | undefined>()
+      expectTypeOf(json.vaultAddress).toEqualTypeOf<`0x${string}`>()
+      void json
+      return
+    }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'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/positions/:address', 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)}`,
+      },
+    })
+
+    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.account).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.assetAllowance).toEqualTypeOf<string>()
+      expectTypeOf(json.assetBalance).toEqualTypeOf<string>()
+      expectTypeOf(json.assetToken).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.id).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.shareAllowance).toEqualTypeOf<string>()
+      expectTypeOf(json.shareBalance).toEqualTypeOf<string>()
+      expectTypeOf(json.shareToken).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.value).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' | '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({
+      param: {
+        address: `0x${'bb'.repeat(20)}`,
+        vaultId: `0x${'aa'.repeat(20)}`,
+      },
+    })
+
+    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.getEarnVaultEarnings.Response>>()
+      expectTypeOf(json.account).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.assetToken).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.currentValue).toEqualTypeOf<string>()
+      expectTypeOf(json.id).toEqualTypeOf<`0x${string}`>()
+      expectTypeOf(json.period).toEqualTypeOf<'active' | 'lifetime'>()
+      expectTypeOf(json.status).toEqualTypeOf<
+        'complete' | 'incomplete_cost_basis' | 'pending_redemption'
+      >()
+      if (json.status === 'complete' && json.period === 'active')
+        expectTypeOf(json.activeEarnings).toEqualTypeOf<string>()
+      if (json.status === 'complete' && json.period === 'lifetime')
+        expectTypeOf(json.lifetimeEarnings).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' | 'earnings_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/me', async () => {
     const client = Client.create()
     const res = await client.v1.me.$get()
@@ -392,7 +636,7 @@ describe('narrows responses by status', () => {
       case 403: {
         const json = await res.json()
         expectTypeOf(json.error.code).toEqualTypeOf<
-          'api_key_forbidden' | 'billing_source_disabled' | 'forbidden'
+          'api_key_forbidden' | 'api_key_ip_forbidden' | 'billing_source_disabled' | 'forbidden'
         >()
         void json
         return
@@ -679,7 +923,7 @@ describe('narrows responses by status', () => {
     const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
       ':projectId{prj_[A-Za-z0-9_-]+}'
     ]['api-keys'].$post({
-      json: { scopes: ['data:read'] },
+      json: { allowedIps: ['203.0.113.0/24'], scopes: ['data:read'] },
       param: { orgId: 'org_test', projectId: 'prj_test' },
     })
 
@@ -690,6 +934,7 @@ describe('narrows responses by status', () => {
         const json = await res.json()
         expectTypeOf(json.token).toEqualTypeOf<string>()
         expectTypeOf(json.id).toEqualTypeOf<string>()
+        expectTypeOf(json.allowedIps).toEqualTypeOf<readonly string[]>()
         void json
         return
       }
@@ -717,6 +962,7 @@ describe('narrows responses by status', () => {
         const json = await res.json()
         expectTypeOf(json.data[0]!.id).toEqualTypeOf<string>()
         expectTypeOf(json.data[0]!.environment).toEqualTypeOf<'production' | 'sandbox'>()
+        expectTypeOf(json.data[0]!.allowedIps).toEqualTypeOf<readonly string[]>()
         // Absent on org-wide keys minted without project attribution.
         expectTypeOf(json.data[0]!.projectId).toEqualTypeOf<string | undefined>()
         void json
@@ -725,6 +971,24 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('PATCH /v1/orgs/:orgId/projects/:projectId/api-keys/:keyId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
+      ':projectId{prj_[A-Za-z0-9_-]+}'
+    ]['api-keys'][':keyId{key_[A-Za-z0-9_-]+}'].$patch({
+      json: { allowedIps: [] },
+      param: { keyId: 'key_test', orgId: 'org_test', projectId: 'prj_test' },
+    })
+
+    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
+    }
+  })
+
   test('DELETE /v1/orgs/:orgId/projects/:projectId/api-keys/:keyId', async () => {
     const client = Client.create()
     const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
@@ -928,7 +1192,7 @@ describe('narrows responses by status', () => {
       }
       case 403: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'api_key_ip_forbidden'>()
         expectTypeOf(json.error.message).toEqualTypeOf<string>()
         void json
         return
@@ -1145,7 +1409,7 @@ describe('narrows responses by status', () => {
         expectTypeOf(json.feeToken).toEqualTypeOf<
           z.output<typeof Tokens.schema.TokenReference> | undefined
         >()
-        expectTypeOf(json.meta.pricing).toEqualTypeOf<
+        expectTypeOf(json.meta.valuation).toEqualTypeOf<
           z.output<typeof Valuation.schema.Pricing> | undefined
         >()
         void json
@@ -1496,7 +1760,7 @@ describe('narrows responses by status', () => {
     const client = Client.create()
     const res = await client.v1.addresses[':address'].valuation.$get({
       param: { address: '0x0000000000000000000000000000000000000000' },
-      query: {},
+      query: { currency: 'AUD' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
@@ -1622,16 +1886,22 @@ describe('narrows responses by status', () => {
           | undefined
         >()
         expectTypeOf(json.data[0]!.sourceAmount).toEqualTypeOf<
-          z.output<typeof Funding.schema.quoteFunding.Response>['data'][number]['sourceAmount']
+          z.output<
+            typeof FundingQuotes.schema.quoteFunding.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
-        expectTypeOf(json.data[0]!.provider.id).toEqualTypeOf<
-          'across' | 'relay' | 'rhino' | 'squid' | 'symbiosis'
-        >()
+        expectTypeOf(json.data[0]!.provider.id).toEqualTypeOf<string>()
         expectTypeOf(json.data[0]!.quote.expiresAt).toEqualTypeOf<string | undefined>()
+        expectTypeOf(json.data[0]!.destinationChain.addressFormat).toEqualTypeOf<
+          'base58' | 'base58check' | 'hex'
+        >()
+        expectTypeOf(json.data[0]!.sourceChain.addressFormat).toEqualTypeOf<
+          'base58' | 'base58check' | 'hex'
+        >()
         void json
         return
       }
@@ -1663,9 +1933,10 @@ describe('narrows responses by status', () => {
         const json = await res.json()
         expectTypeOf(json.data[0]!.tokens[0]!.symbol).toEqualTypeOf<
           z.output<
-            typeof Funding.schema.listFundingChains.Response
+            typeof FundingChains.schema.getFundingChains.Response
           >['data'][number]['tokens'][number]['symbol']
         >()
+        expectTypeOf(json.data[0]!.addressFormat).toEqualTypeOf<'base58' | 'base58check' | 'hex'>()
         void json
         return
       }
@@ -1688,15 +1959,401 @@ describe('narrows responses by status', () => {
     switch (res.status) {
       case 200: {
         const json = await res.json()
+        expectTypeOf(json.data[0]!.id).toEqualTypeOf<string>()
+        // @ts-expect-error providers no longer expose deployment configuration state
+        void json.data[0]!.status
+        void json
+        return
+      }
+      case 400: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_malformed'>()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('POST /v1/funding/deposit-addresses', async () => {
+    const client = Client.create()
+    const json = {
+      amount: '100000000',
+      destinationToken: '0x20c00000000000000000000014f22ca97301eb73',
+      recipient: `0x${'11'.repeat(20)}`,
+      refundAddress: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
+      sourceChain: 'tron:0x2b6653dc',
+      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' },
+      json,
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.id).toEqualTypeOf<string>()
+        expectTypeOf(json.status).toEqualTypeOf<
+          z.output<
+            typeof FundingDepositAddresses.schema.createFundingDepositAddress.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']
+          >()
+          expectTypeOf(json.quote.sampledAt).toEqualTypeOf<string>()
+          expectTypeOf(json.sourceAmount.baseUnits).toEqualTypeOf<string>()
+        }
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'deposit_address_not_available'>()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'idempotency_conflict' | 'idempotency_in_progress'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/funding/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' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.status).toEqualTypeOf<
+          z.output<typeof FundingDepositAddresses.schema.DepositAddress>['status']
+        >()
+        expectTypeOf(json.sourceChain.kind).toEqualTypeOf<'evm' | 'solana' | 'tron'>()
+        expectTypeOf(json.subsidize).toEqualTypeOf<boolean>()
+        // @ts-expect-error provider routing remains private
+        void json.providerOutputToken
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('POST /v1/funding/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' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<202 | 400 | 401 | 403 | 404 | 409 | 429 | 501 | 502>()
+
+    switch (res.status) {
+      case 202: {
+        expectTypeOf(await res.text()).toEqualTypeOf<string>()
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_found'>()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_active'>()
+        void json
+        return
+      }
+      case 501: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'not_implemented'>()
+        void json
+        return
+      }
+      case 502: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/funding/deposit-addresses/:id/deposits', async () => {
+    const client = Client.create()
+    const res = await client.v1.funding['deposit-addresses'][
+      ':id{fda_[A-Za-z0-9_-]+}'
+    ].deposits.$get({ param: { id: 'fda_test' }, query: {} })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.data[0]!.detectionTrigger).toEqualTypeOf<
+          'chain' | 'manual' | 'poll' | 'webhook' | undefined
+        >()
         expectTypeOf(json.data[0]!.status).toEqualTypeOf<
-          z.output<typeof Funding.schema.listProviders.Response>['data'][number]['status']
+          z.output<typeof FundingDepositAddresses.schema.Deposit>['status']
         >()
+        expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/funding/deposits', async () => {
+    const client = Client.create()
+    // @ts-expect-error `recipient` is required for the deposit list.
+    void client.v1.funding.deposits.$get({ query: {} })
+    const res = await client.v1.funding.deposits.$get({
+      query: { recipient: `0x${'11'.repeat(20)}` },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        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']
+        >()
+        expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/funding/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' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.detectionTrigger).toEqualTypeOf<
+          'chain' | 'manual' | 'poll' | 'webhook' | undefined
+        >()
+        expectTypeOf(json.destinationAmountRequired).toEqualTypeOf<
+          z.output<typeof FundingDepositAddresses.schema.Deposit>['destinationAmountRequired']
+        >()
+        expectTypeOf(json.sourceTransferIndex).toEqualTypeOf<number | undefined>()
+        expectTypeOf(json.statusReason).toEqualTypeOf<
+          z.output<typeof FundingDepositAddresses.schema.Deposit>['statusReason']
+        >()
+        // @ts-expect-error provider request identifiers remain private
+        void json.providerRequestIds
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/funding/transfers', async () => {
+    const client = Client.create()
+    const res = await client.v1.funding.transfers.$get({ query: {} })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        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']
+        >()
+        expectTypeOf(json.data[0]!.version).toEqualTypeOf<number>()
+        // Transfer reads never expose the executable action.
+        // @ts-expect-error `action` is a creation-only field
+        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']
+        >()
+        expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
         void json
         return
       }
       case 400: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_malformed'>()
+        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('POST /v1/funding/transfers', async () => {
+    const client = Client.create()
+    const json = {
+      amount: '1000000',
+      destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
+      mode: 'exactSource',
+      recipient: `0x${'11'.repeat(20)}`,
+      sender: `0x${'22'.repeat(20)}`,
+      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' },
+      json,
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.action.type).toEqualTypeOf<'evm:calls'>()
+        expectTypeOf(json.id).toEqualTypeOf<string>()
+        expectTypeOf(json.status).toEqualTypeOf<
+          z.output<typeof FundingTransfers.schema.createFundingTransfer.Response>['status']
+        >()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'quote_not_available'>()
+        void json
+        return
+      }
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'idempotency_conflict' | 'idempotency_in_progress'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
+  test('POST /v1/funding/transfers/vault', async () => {
+    const client = Client.create()
+    const json = {
+      amount: '1000000',
+      mode: 'exactSource',
+      recipient: `0x${'11'.repeat(20)}`,
+      sender: `0x${'22'.repeat(20)}`,
+      sourceChain: 'eip155:8453',
+      sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+      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' },
+      json,
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<400 | 501 | PublicAccessStatus>()
+    if (res.status === 501) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'not_implemented'>()
+      void json
+    }
+  })
+
+  test('POST /v1/funding/transfers/zone', async () => {
+    const client = Client.create()
+    const json = {
+      amount: '1000000',
+      destinationChain: 'eip155:421700001',
+      destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
+      mode: 'exactSource',
+      recipient: `0x${'11'.repeat(20)}`,
+      recipientFallback: `0x${'33'.repeat(20)}`,
+      sender: `0x${'22'.repeat(20)}`,
+      sourceChain: 'eip155:8453',
+      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' },
+      json,
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<400 | 501 | PublicAccessStatus>()
+    if (res.status === 501) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'not_implemented'>()
+      void json
+    }
+  })
+
+  test('GET /v1/funding/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' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.id).toEqualTypeOf<string>()
+        expectTypeOf(json.status).toEqualTypeOf<
+          z.output<typeof FundingTransfers.schema.getFundingTransfer.Response>['status']
+        >()
+        expectTypeOf(json.statusReason).toEqualTypeOf<
+          z.output<typeof FundingTransfers.schema.getFundingTransfer.Response>['statusReason']
+        >()
+        // @ts-expect-error `action` is a creation-only field
+        void json.action
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'funding_transfer_not_found'>()
         expectTypeOf(json.error.message).toEqualTypeOf<string>()
         void json
         return
@@ -1748,6 +2405,7 @@ describe('narrows responses by status', () => {
     const client = Client.create()
     const res = await client.v1.exchange.quotes.$post({
       json: {
+        account: '0x1111111111111111111111111111111111111111',
         amount: '1000000',
         destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
         mode: 'exactSource',
@@ -1768,7 +2426,7 @@ describe('narrows responses by status', () => {
         expectTypeOf(json.destinationToken.logoUri).toEqualTypeOf<string | undefined>()
         expectTypeOf(json.destinationToken.symbol).toEqualTypeOf<string>()
         expectTypeOf(json.destinationToken.verified).toEqualTypeOf<boolean | undefined>()
-        expectTypeOf(json.meta?.pricing).toEqualTypeOf<
+        expectTypeOf(json.meta?.valuation).toEqualTypeOf<
           z.output<typeof Valuation.schema.Pricing> | undefined
         >()
         expectTypeOf(json.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
@@ -1777,11 +2435,19 @@ describe('narrows responses by status', () => {
         expectTypeOf(json.sourceToken.logoUri).toEqualTypeOf<string | undefined>()
         expectTypeOf(json.sourceToken.symbol).toEqualTypeOf<string>()
         expectTypeOf(json.sourceToken.verified).toEqualTypeOf<boolean | undefined>()
-        expectTypeOf(json.transaction.calls[0]!.data).toEqualTypeOf<
-          z.output<
-            typeof Exchanges.schema.createQuote.Response
-          >['transaction']['calls'][number]['data']
-        >()
+        expectTypeOf(json.gasEstimate).toEqualTypeOf<string>()
+        if (json.status === 'approvalRequired')
+          expectTypeOf(json.approval.calls[0]!.data).toEqualTypeOf<
+            z.output<typeof Exchanges.schema.createQuote.Call>['data']
+          >()
+        if (json.status === 'signatureRequired') {
+          expectTypeOf(json.continuation).toEqualTypeOf<string>()
+          expectTypeOf(json.typedData.primaryType).toEqualTypeOf<string>()
+        }
+        if (json.status === 'ready')
+          expectTypeOf(json.transaction.calls[0]!.data).toEqualTypeOf<
+            z.output<typeof Exchanges.schema.createQuote.Call>['data']
+          >()
         if (json.mode === 'exactSource') {
           expectTypeOf(json.destinationAmountMin).toEqualTypeOf<ValuedTokenAmount>()
           // @ts-expect-error slippage quantities live on destinationAmountMin
@@ -1828,6 +2494,45 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('POST /v1/exchange/quotes/execute', async () => {
+    const client = Client.create()
+    const res = await client.v1.exchange.quotes.execute.$post({
+      json: {
+        account: '0x1111111111111111111111111111111111111111',
+        continuation: 'eyJxdW90ZSI6e319',
+        provider: 'uniswap',
+        signature: `0x${'11'.repeat(65)}`,
+      },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.provider).toEqualTypeOf<string>()
+        expectTypeOf(json.transaction.calls[0]!.data).toEqualTypeOf<
+          z.output<typeof Exchanges.schema.createQuote.Call>['data']
+        >()
+        return
+      }
+      case 400: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          Access400<
+            'body_invalid' | 'query_invalid' | 'swap_continuation_invalid' | 'swap_provider_invalid'
+          >
+        >()
+        return
+      }
+      case 502: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+        return
+      }
+    }
+  })
+
   test('GET /v1/exchange/pairs', async () => {
     const client = Client.create()
     const res = await client.v1.exchange.pairs.$get()
@@ -2343,6 +3048,71 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('GET /v1/zones/withdrawals/:senderTag', async () => {
+    const client = Client.create()
+    const res = await client.v1.zones.withdrawals[':senderTag'].$get({
+      param: {
+        senderTag: '0x61fc42a734cb44acef497ea0bed612c691195623244136e0739e1929569e2487',
+      },
+      query: { chainId: '421700001' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json).toEqualTypeOf<
+          z.output<typeof Zones.schema.listZoneWithdrawals.Response>
+        >()
+        const withdrawal = json.data[0]!
+        expectTypeOf(withdrawal.blockNumber).toEqualTypeOf<number>()
+        expectTypeOf(withdrawal.id).toEqualTypeOf<string>()
+        expectTypeOf(withdrawal.logIndex).toEqualTypeOf<number>()
+        expectTypeOf(withdrawal.status).toEqualTypeOf<'completed' | 'failed'>()
+        expectTypeOf(withdrawal.transactionHash).toEqualTypeOf<`0x${string}`>()
+        expectTypeOf(withdrawal.zoneStatus).toEqualTypeOf<'completed' | 'pending'>()
+        void json
+        return
+      }
+      case 400: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          Access400<
+            'chain_id_invalid' | 'chain_id_unsupported' | 'query_invalid' | 'sender_tag_invalid'
+          >
+        >()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 401: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_invalid' | 'api_key_missing'>()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'api_key_ip_forbidden'>()
+        void json
+        return
+      }
+      case 429: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'payment_required' | 'rate_limit_exceeded'>()
+        void json
+        return
+      }
+      case 502: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+        void json
+        return
+      }
+    }
+  })
+
   test('POST /rpc/:chain', async () => {
     const client = Client.create()
     const res = await client.rpc[':chain{(mainnet|testnet|[0-9]+)}?'].$post({
@@ -2500,7 +3270,9 @@ describe('narrows responses by status', () => {
     }
     if (res.status === 403) {
       const json = await res.json()
-      expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'limit_exceeded'>()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        'api_key_forbidden' | 'api_key_ip_forbidden' | 'limit_exceeded'
+      >()
     }
   })