tapimo 0.15.1 → 0.18.1

package/src/apps/routes/routes/transfers.ts

@@ -12,10 +12,13 @@ import * as Auth from '../../../internal/Auth.js'
 import * as Cache from '../../../internal/Cache.js'
 import * as RoutesCatalog from '../../../internal/routes/Catalog.js'
 import * as RoutesObservability from '../../../internal/routes/Observability.js'
+import * as RoutesPolicy from '../../../internal/routes/Policy.js'
 import * as RoutesProvider from '../../../internal/routes/Provider.js'
+import type * as RoutesSolanaTransferSubsidy from '../../../internal/routes/SolanaTransferSubsidy.js'
 import * as RoutesSubsidy from '../../../internal/routes/Subsidy.js'
 import * as RoutesTransfer from '../../../internal/routes/Transfer.js'
 import * as RoutesTransferSubsidy from '../../../internal/routes/TransferSubsidy.js'
+import type * as RoutesTronTransferSubsidy from '../../../internal/routes/TronTransferSubsidy.js'
 import * as RoutesTransferReconciliation from '../../../internal/routes/TransferReconciliation.js'
 import * as Idempotency from '../../../internal/Idempotency.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
@@ -97,7 +100,12 @@ export namespace schema {
     recipient: RoutesTransfer.schema.CreateRequest.shape.recipient,
     sender: RoutesTransfer.schema.CreateRequest.shape.sender,
     slippageBps: RoutesTransfer.schema.CreateRequest.shape.slippageBps,
-    sourceChain: RoutesTransfer.schema.CreateRequest.shape.sourceChain,
+    sourceChain: z
+      .nonoptional(RoutesTransfer.schema.CreateRequest.shape.sourceChain)
+      .check(
+        z.describe('Source chain CAIP-2 id, slug, or alias.'),
+        z.meta({ examples: ['tempo', 'base', 'ethereum', 'eip155:4217'] }),
+      ),
     sourceToken: RoutesTransfer.schema.CreateRequest.shape.sourceToken,
   }
 
@@ -179,6 +187,18 @@ export namespace schema {
     export const Response = Transfer
   }
 
+  /** EVM hashes or native Tron transaction IDs, validated against the stored source chain before use. */
+  export const SourceTransactionHash = z.pipe(
+    z
+      .string()
+      .check(
+        z.regex(/^(?:0x)?[0-9a-fA-F]{64}$/),
+        z.describe('Transaction hash; Tron transaction IDs may omit the 0x prefix.'),
+        z.meta({ examples: [`0x${'51'.repeat(32)}`] }),
+      ),
+    z.transform((value) => value.toLowerCase()),
+  )
+
   /** Schemas for the registerRoutesTransferSourceTransaction operation. */
   export namespace registerRoutesTransferSourceTransaction {
     /** Source transaction registration request body. */
@@ -186,11 +206,11 @@ export namespace schema {
       z
         .union([
           z.strictObject({
-            transactionHash: Schema.hash(`0x${'51'.repeat(32)}`),
+            transactionHash: SourceTransactionHash,
           }),
           z.strictObject({
             transactionHashes: z
-              .array(Schema.hash(`0x${'52'.repeat(32)}`))
+              .array(SourceTransactionHash)
               .check(
                 z.minLength(1),
                 z.maxLength(maximumSourceTransactionHashes),
@@ -394,6 +414,11 @@ const paramValidation = {
 
 /** Mounts durable route transfer routes. */
 export function transfers(options: transfers.Options = {}) {
+  const inventoryFor = (chainId: string) => {
+    if (chainId.startsWith('solana:')) return options.solanaTransferSubsidy
+    if (chainId === 'tron:0x2b6653dc') return options.tronTransferSubsidy
+    return options.transferSubsidy
+  }
   return new Hono<App.Environment>()
     .get(
       '/v1/routes/transfers',
@@ -608,7 +633,7 @@ export function transfers(options: transfers.Options = {}) {
         const db = Db.get(c.get('db'))
         const { id } = c.req.valid('param')
         const body = c.req.valid('json')
-        const transactionHashes = [
+        const submittedHashes = [
           ...new Set('transactionHash' in body ? [body.transactionHash] : body.transactionHashes),
         ]
         try {
@@ -619,6 +644,18 @@ export function transfers(options: transfers.Options = {}) {
               message: 'Route transfer not found',
               status: 404,
             })
+          if (
+            record.snapshot.sourceChain.kind !== 'tron' &&
+            submittedHashes.some((hash) => !hash.startsWith('0x'))
+          )
+            return Response.error(c, {
+              code: 'source_transaction_invalid',
+              message: 'Source transaction hashes must include the 0x prefix',
+              status: 400,
+            })
+          const transactionHashes = [
+            ...new Set(submittedHashes.map((hash) => (hash.startsWith('0x') ? hash : `0x${hash}`))),
+          ]
           if (
             transactionHashes.every((transactionHash) =>
               record.snapshot.sourceTransactionHashes?.some(
@@ -821,8 +858,11 @@ export function transfers(options: transfers.Options = {}) {
               codes: [
                 'billing_past_due',
                 'billing_required',
+                'routes_not_allowed',
                 'routes_subsidy_limit_exceeded',
+                'routes_subsidy_not_allowed',
                 'routes_subsidy_not_enabled',
+                'routes_suspended',
               ],
               description: 'The requested normalized delivery subsidy is unavailable.',
             },
@@ -831,7 +871,7 @@ export function transfers(options: transfers.Options = {}) {
               description: 'No provider can prepare the requested route.',
             },
             409: {
-              codes: ['idempotency_conflict', 'idempotency_in_progress'],
+              codes: ['idempotency_conflict', 'idempotency_in_progress', 'route_policy_changed'],
               description: 'The Idempotency-Key conflicts with an existing or in-flight request.',
             },
             501: {
@@ -938,7 +978,12 @@ export function transfers(options: transfers.Options = {}) {
           }
         }
         try {
-          if (subsidize && !options.transferSubsidy) {
+          if (
+            subsidize &&
+            !options.transferSubsidy &&
+            !options.solanaTransferSubsidy &&
+            !options.tronTransferSubsidy
+          ) {
             await release()
             return Response.error(c, {
               code: 'not_implemented',
@@ -946,30 +991,122 @@ export function transfers(options: transfers.Options = {}) {
               status: 501,
             })
           }
-          const subsidyPolicy = subsidize
-            ? await RoutesSubsidy.check(db, {
-                environment: owner.environment,
-                orgId: owner.orgId,
-              })
-            : undefined
-          if (subsidyPolicy?.type === 'denied') {
+          const [fullCatalog, policyContext] = await Promise.all([
+            RoutesCatalog.snapshot(c),
+            Access.loadPolicy(c),
+          ])
+          if (!policyContext) return Access.unauthorized(c)
+          const legacy = Access.isLegacy(policyContext)
+          const legacyPolicy =
+            subsidize && legacy ? await RoutesSubsidy.check(db, owner) : undefined
+          if (legacyPolicy?.type === 'denied') {
             RoutesObservability.recordSubsidyRejection(c.get('metrics'), {
-              reason: subsidyPolicy.reason,
+              reason: legacyPolicy.reason,
               routesEnvironment: owner.environment,
             })
             await release()
             return Response.error(c, {
-              code: subsidyPolicy.reason,
-              message: RoutesSubsidy.denialMessages[subsidyPolicy.reason],
+              code: legacyPolicy.reason,
+              message: RoutesSubsidy.denialMessages[legacyPolicy.reason],
               status: 403,
             })
           }
           const attempts: RoutesProvider.ProviderAttempt[] = []
-          const catalog = await RoutesCatalog.snapshot(c)
+          const catalog = Access.filterCatalog(fullCatalog, policyContext, subsidize)
           const providers = c.get('providers').filter(RoutesProvider.is)
+          const destinationChain = body.destinationChain ?? `eip155:${c.get('chainId')}`
+          const request = {
+            destinationChain,
+            destinationToken: body.destinationToken,
+            method: 'transaction' as const,
+            mode: body.mode,
+            provider: body.provider,
+            providers,
+            sourceAmount: body.amount,
+            sourceChain: body.sourceChain ?? destinationChain,
+            sourceToken: body.sourceToken,
+          }
+          const candidates = RoutesProvider.getPrepareCandidates({
+            ...request,
+            catalog: fullCatalog,
+          })
+          const allowed = candidates.filter(({ candidate }) =>
+            catalog.routes.some((entry) => entry.route === candidate.route),
+          )
+          if (candidates.length > 0 && allowed.length === 0)
+            throw new Access.PolicyError(
+              subsidize ? 'routes_subsidy_not_allowed' : 'routes_not_allowed',
+            )
+          const permitted = allowed.filter(
+            ({ candidate }) =>
+              !subsidize || inventoryFor(candidate.destinationChain.id) !== undefined,
+          )
+          if (subsidize && allowed.length > 0 && permitted.length === 0) {
+            await release()
+            return Response.error(c, {
+              code: 'not_implemented',
+              message: 'Destination subsidy settlement is not configured for this chain.',
+              status: 501,
+            })
+          }
+          if (permitted.length === 0) {
+            await release()
+            return quoteNotAvailable(c)
+          }
+          const commitments = new Map<
+            RoutesProvider.QuoteCandidate['route'],
+            RoutesPolicy.Commitment
+          >()
+          if (subsidize && !legacy) {
+            let denied: Access.PolicyError | undefined
+            for (const { candidate } of permitted) {
+              try {
+                commitments.set(
+                  candidate.route,
+                  await Access.commitment(
+                    db,
+                    policyContext,
+                    RoutesPolicy.fromRoute({
+                      providerId: candidate.provider.id,
+                      route: candidate.route,
+                    }),
+                    inventoryFor(candidate.destinationChain.id)!.policy.maxAmount,
+                  ),
+                )
+              } catch (cause) {
+                if (!(cause instanceof Access.PolicyError)) throw cause
+                denied = cause
+              }
+            }
+            if (commitments.size === 0 && denied) throw denied
+          }
+          let subsidyLimitExceeded = false
           const selected = await RoutesProvider.prepareTransfer({
-            catalog,
-            destinationChain: body.destinationChain ?? `eip155:${c.get('chainId')}`,
+            accept:
+              subsidize && !legacy
+                ? (candidate, result) => {
+                    const required = RoutesTransferSubsidy.requiredAmount({
+                      destinationToken: candidate.destinationToken,
+                      sourceAmount: candidate.sourceAmount.amount,
+                      sourceToken: candidate.sourceToken,
+                    })
+                    const minimum = BigInt(result.destinationAmountMin)
+                    const accepted = RoutesSubsidy.supportsGap(commitments.get(candidate.route)!, {
+                      amount: required > minimum ? required - minimum : 0n,
+                      destinationToken: candidate.destinationToken,
+                    })
+                    if (!accepted) subsidyLimitExceeded = true
+                    return accepted
+                  }
+                : undefined,
+            catalog:
+              subsidize && !legacy
+                ? {
+                    ...catalog,
+                    routes: catalog.routes.filter((entry) => commitments.has(entry.route)),
+                  }
+                : catalog,
+            destinationChain: request.destinationChain,
             destinationToken: body.destinationToken,
             method: 'transaction',
             mode: body.mode,
@@ -980,17 +1117,26 @@ export function transfers(options: transfers.Options = {}) {
             sender: body.sender,
             slippageBps: body.slippageBps,
             sourceAmount: body.amount,
-            sourceChain: body.sourceChain,
+            sourceChain: request.sourceChain,
             sourceToken: body.sourceToken,
           })
           if (attempts.length > 0)
             c.set('routesProviderAttempts', attempts.map(RoutesProvider.formatAttempt))
           if (!selected) {
             await release()
+            if (subsidyLimitExceeded)
+              return Response.error(c, {
+                code: 'routes_subsidy_limit_exceeded',
+                message: 'The required destination subsidy exceeds the configured limit.',
+                status: 403,
+              })
             return quoteNotAvailable(c)
           }
 
           const { candidate, result } = selected
+          const transferSubsidy = inventoryFor(candidate.destinationChain.id)
+          const routePolicy = commitments.get(candidate.route)
+          const subsidyPolicy = routePolicy ?? legacyPolicy
           const subsidyDestinationChain = subsidize
             ? catalog.chainsByKey.get(candidate.destinationChain.id)
             : undefined
@@ -1000,13 +1146,17 @@ export function transfers(options: transfers.Options = {}) {
           }
           if (
             subsidize &&
-            (candidate.sourceChain.id !== `eip155:${c.get('chainId')}` ||
-              !['eip155:1', 'eip155:8453'].includes(candidate.destinationChain.id))
+            !RoutesTransferSubsidy.supportsRoute({
+              destinationChainId: candidate.destinationChain.id,
+              sourceChainId: candidate.sourceChain.id,
+              tempoChainId: c.get('chainId'),
+            })
           ) {
             await release()
             return Response.error(c, {
               code: 'body_invalid',
-              message: 'Destination subsidies support Tempo transfers to Base or Ethereum.',
+              message:
+                'Destination subsidies support transfers to Tempo and Tempo transfers to Base, Ethereum, Solana, or Tron.',
               status: 400,
             })
           }
@@ -1024,13 +1174,13 @@ export function transfers(options: transfers.Options = {}) {
               : 0n
           if (
             destinationAmountRequired !== undefined &&
-            subsidyPolicy?.type === 'allowed' &&
+            subsidyPolicy !== undefined &&
             (!RoutesSubsidy.supportsGap(subsidyPolicy, {
               amount: subsidyAmount,
               destinationToken: candidate.destinationToken,
             }) ||
-              (options.transferSubsidy !== undefined &&
-                !RoutesSubsidy.supportsGap(options.transferSubsidy.policy, {
+              (transferSubsidy !== undefined &&
+                !RoutesSubsidy.supportsGap(transferSubsidy.policy, {
                   amount: subsidyAmount,
                   destinationToken: candidate.destinationToken,
                 })))
@@ -1098,33 +1248,57 @@ export function transfers(options: transfers.Options = {}) {
           // The transfer row, its version-1 event, and the replay body commit
           // atomically so a crash cannot leave a claimed key without a replay.
           const created = await db.transaction(async (tx) => {
+            await Access.assertPolicy(tx, policyContext)
             const input: RoutesTransfer.create.Input = {
               apiKeyId: principal.id,
               environment: owner.environment,
               orgId: owner.orgId,
               projectId: owner.projectId,
               providerState:
-                result.correlation || result.providerState
+                result.correlation || result.providerState || routePolicy
                   ? {
                       ...result.correlation,
                       ...result.providerState,
+                      ...(routePolicy === undefined
+                        ? {}
+                        : {
+                            routePolicy,
+                            routePolicyKey: RoutesPolicy.commitmentKey(routePolicy),
+                          }),
                     }
                   : undefined,
               snapshot,
             }
             const { record, references } =
-              subsidize && subsidyAmount > 0n && options.transferSubsidy
+              subsidize && subsidyAmount > 0n && transferSubsidy
                 ? await RoutesTransfer.reserveSubsidyCommitmentIn(tx, input, {
-                    account: options.transferSubsidy.account,
+                    account: transferSubsidy.account,
                     chainId: candidate.destinationChain.id,
-                    check: ({ reservations }) =>
-                      options.transferSubsidy!.check({
+                    check: ({ reservations }) => {
+                      if (candidate.destinationChain.kind === 'solana')
+                        return options.solanaTransferSubsidy!.check({
+                          amount: subsidyAmount,
+                          chain: subsidyDestinationChain!,
+                          recipient: selected.recipient,
+                          reservations,
+                          token: candidate.destinationToken.address,
+                        })
+                      if (candidate.destinationChain.id === 'tron:0x2b6653dc')
+                        return options.tronTransferSubsidy!.check({
+                          amount: subsidyAmount,
+                          chain: subsidyDestinationChain!,
+                          recipient: selected.recipient,
+                          reservations,
+                          token: candidate.destinationToken.address,
+                        })
+                      return options.transferSubsidy!.check({
                         amount: subsidyAmount,
                         chain: subsidyDestinationChain!,
                         recipient: getAddress(selected.recipient),
                         reservations,
                         token: getAddress(candidate.destinationToken.address),
-                      }),
+                      })
+                    },
                     subsidyCommitmentAmount: Value.tokenAmount({
                       baseUnits: subsidyAmount,
                       currency: candidate.destinationToken.currency,
@@ -1164,6 +1338,7 @@ export function transfers(options: transfers.Options = {}) {
           return c.json(created.response, 200)
         } catch (cause) {
           await release()
+          if (cause instanceof Access.PolicyError) return Access.policyError(c, cause)
           if (cause instanceof RoutesProvider.InvalidAmountError)
             return Response.error(c, { code: 'body_invalid', message: 'Invalid `amount`.', status: 400 }) // prettier-ignore
           if (cause instanceof RoutesProvider.InvalidRecipientAddressError)
@@ -1201,7 +1376,7 @@ export function transfers(options: transfers.Options = {}) {
           if (cause instanceof RoutesTransferSubsidy.BalanceUnavailableError)
             return Response.error(c, {
               code: 'subsidy_inventory_unavailable',
-              message: 'Tempo lacks enough destination token inventory or native gas.',
+              message: 'Tempo lacks enough destination token inventory or transaction fee funds.',
               status: 503,
             })
           if (cause instanceof RoutesTransferSubsidy.InventoryUpstreamError)
@@ -1308,6 +1483,10 @@ export declare namespace transfers {
       | undefined
     /** Read-only destination subsidy inventory, when settlement is configured. */
     transferSubsidy?: RoutesTransferSubsidy.Inventory | undefined
+    /** Read-only Solana destination subsidy inventory, when settlement is configured. */
+    solanaTransferSubsidy?: RoutesSolanaTransferSubsidy.Inventory | undefined
+    /** Read-only Tron destination subsidy inventory, when settlement is configured. */
+    tronTransferSubsidy?: RoutesTronTransferSubsidy.Inventory | undefined
   }
 }