@xyo-network/chain-bridge 1.19.6 → 1.19.8

package/src/queue/workers/{ethTransactionPreparation.ts → EthTransactionPreparation.ts}

@@ -1,6 +1,8 @@
 import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+import {
+  isBridgeIntent, isSignedTransactionBoundWitness, type SignedHydratedTransaction,
+} from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import { getAddress } from 'ethers'
@@ -9,20 +11,21 @@ import type { Redis } from 'ioredis'
 import type { IBridgeServiceCollection } from '../../services/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = Pick<IBridgeServiceCollection, 'bridge' | 'ethTxStateMap'> & { tx: SignedHydratedTransaction }
+type JobData = { tx: SignedHydratedTransaction }
 
 interface ReturnType {}
 
 const name = 'Prepare ETH Transaction'
 const queueName = 'eth-tx-prepare'
 
-export const createWorker = (connection: Redis) => {
-  new Worker(
+export const createWorker = (connection: Redis, services?: IBridgeServiceCollection) => {
+  const bridge = assertEx(services?.bridge, () => 'bridge service not provided')
+  const stateMap = assertEx(services?.ethTxStateMap, () => 'ethTxStateMap service not provided')
+
+  const worker = new Worker(
     queueName,
     async (job: Job<JobData, ReturnType>) => {
-      const {
-        bridge, ethTxStateMap: stateMap, tx,
-      } = job.data
+      const { tx } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       await job.log(`[${hash}] preparing ETH transaction`)
       await job.log(`[${hash}] building ETH transaction`)
@@ -30,7 +33,8 @@ export const createWorker = (connection: Redis) => {
       const amount = hexToBigInt(bridgeIntent.destAmount)
       const srcAddress = getAddress(bridgeIntent.srcAddress)
       const destAddress = getAddress(bridgeIntent.destAddress)
-      const preparedTx = await bridge.getFunction('bridgeFromRemote').populateTransaction(srcAddress, destAddress, amount, 0n)
+      const nonce = hexToBigInt(await PayloadBuilder.hash(tx[0]))
+      const preparedTx = await bridge.getFunction('bridgeFromRemote').populateTransaction(srcAddress, destAddress, amount, nonce)
       await job.log(`[${hash}] built ETH transaction`)
       await job.log(`[${hash}] storing ETH preparedTx`)
       await stateMap.set(hash, { preparedTx })
@@ -40,8 +44,16 @@ export const createWorker = (connection: Redis) => {
     },
     { connection },
   )
+
+  worker.on('failed', (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message)
+  })
+
+  worker.on('error', (err) => {
+    console.error(`[${name}] Worker error:`, err)
+  })
 }
 
-export const ethTransactionPreparation: WorkerDescription = {
+export const EthTransactionPreparation: WorkerDescription = {
   createWorker, name, queueName,
 }

package/src/queue/workers/{ethTransactionSubmission.ts → EthTransactionSubmission.ts}

@@ -6,9 +6,10 @@ import { Worker } from 'bullmq'
 import type { Redis } from 'ioredis'
 
 import type { EthTxState, IBridgeServiceCollection } from '../../services/index.ts'
+import { submitEthTransaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = Pick<IBridgeServiceCollection, 'bridge' | 'ethTxStateMap' | 'wallet'> & { tx: SignedHydratedTransaction }
+type JobData = { tx: SignedHydratedTransaction }
 
 interface ReturnType {
   submissionHash: Required<EthTxState>['submissionHash']
@@ -16,13 +17,16 @@ interface ReturnType {
 
 const name = 'Submit ETH Transaction'
 const queueName = 'eth-tx-submit'
-const createWorker = (connection: Redis) => {
-  new Worker(
+const createWorker = (connection: Redis, services?: IBridgeServiceCollection) => {
+  const bridge = assertEx(services?.bridge, () => 'bridge service not provided')
+  const bridgeableToken = assertEx(services?.bridgeableToken, () => 'bridgeableToken service not provided')
+  const wallet = assertEx(services?.wallet, () => 'wallet service not provided')
+  const stateMap = assertEx(services?.ethTxStateMap, () => 'ethTxStateMap service not provided')
+
+  const worker = new Worker(
     queueName,
     async (job: Job<JobData, ReturnType>) => {
-      const {
-        ethTxStateMap: stateMap, tx, wallet,
-      } = job.data
+      const { tx } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
       const preparedTx = assertEx(state?.preparedTx, () => `[${hash}] preparedTx not found`)
@@ -36,8 +40,11 @@ const createWorker = (connection: Redis) => {
 
       // Submit the transaction to the Ethereum network
       await job.log(`[${hash}] Submitting ETH tx`)
-      const submissionResponse = await wallet.sendTransaction(preparedTx)
-      const submissionHash = submissionResponse.hash
+      // const submissionResponse = await wallet.sendTransaction(preparedTx)
+      // const submissionHash = submissionResponse.hash
+
+      const submissionHash = assertEx(await submitEthTransaction(tx, bridgeableToken, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`)
+
       await job.log(`[${hash}] Submitted ETH tx and received submission response hash ${submissionHash}`)
 
       // Store the submission hash in the state
@@ -70,8 +77,16 @@ const createWorker = (connection: Redis) => {
     },
     { connection, concurrency: 1 },
   )
+
+  worker.on('failed', (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message)
+  })
+
+  worker.on('error', (err) => {
+    console.error(`[${name}] Worker error:`, err)
+  })
 }
 
-export const ethTransactionSubmission: WorkerDescription = {
+export const EthTransactionSubmission: WorkerDescription = {
   createWorker, name, queueName,
 }

package/src/queue/workers/WorkerDescription.ts

@@ -1,7 +1,9 @@
 import type { Redis } from 'ioredis'
 
+import type { IBridgeServiceCollection } from '../../services/index.ts'
+
 export interface WorkerDescription {
-  createWorker: (connection: Redis) => void
+  createWorker: (connection: Redis, services?: IBridgeServiceCollection) => void
   name: string
   queueName: string
 }

package/src/queue/workers/{xl1ToEthBridgeParent.ts → Xl1ToEthBridgeParent.ts}

@@ -7,7 +7,7 @@ import type { WorkerDescription } from './WorkerDescription.ts'
 const name = 'Bridge XL1 to Ethereum'
 const queueName = 'xl1-to-eth-bridge'
 const createWorker = (connection: Redis) => {
-  new Worker(
+  const worker = new Worker(
     queueName,
     async (job: Job) => {
       await job.log(`[${job.name}] start`)
@@ -18,8 +18,16 @@ const createWorker = (connection: Redis) => {
     },
     { connection },
   )
+
+  worker.on('failed', (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message)
+  })
+
+  worker.on('error', (err) => {
+    console.error(`[${name}] Worker error:`, err)
+  })
 }
 
-export const xl1ToEthBridgeParent: WorkerDescription = {
+export const Xl1ToEthBridgeParent: WorkerDescription = {
   createWorker, name, queueName,
 }

package/src/queue/workers/{xl1TransactionMonitor.ts → Xl1TransactionMonitor.ts}

@@ -10,35 +10,37 @@ import type { Redis } from 'ioredis'
 import type { IBridgeServiceCollection } from '../../services/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = Pick<IBridgeServiceCollection, 'gateway' | 'xl1TxStateMap'> & { tx: SignedHydratedTransaction }
+type JobData = { tx: SignedHydratedTransaction }
 
 interface ReturnType {
 }
 
 const name = 'Monitor Submitted XL1 Transaction'
 const queueName = 'xl1-tx-monitor'
-const createWorker = (connection: Redis) => {
-  new Worker(
+const createWorker = (connection: Redis, services?: IBridgeServiceCollection) => {
+  const gateway = assertEx(services?.gateway, () => 'gateway service not provided')
+  const stateMap = assertEx(services?.xl1TxStateMap, () => 'xl1TxStateMap service not provided')
+
+  const worker = new Worker(
     queueName,
     async (job: Job<JobData, ReturnType>) => {
-      const {
-        gateway, tx, xl1TxStateMap: stateMap,
-      } = job.data
+      const { tx } = job.data
       // Get the hash of the transaction
       const hash = await PayloadBuilder.hash(tx[0])
       // Get the state of the transaction
       const viewer = assertEx(gateway.connection.viewer, () => `[${hash}] viewer not defined on gateway`)
       const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
+      const submissionHash = assertEx(state?.submissionHash, () => `[${hash}] submissionHash not found`)
 
       // Check for transaction inclusion on chain
       await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`)
-      const foundTx = await viewer.transactionByHash(hash)
+      const foundTx = await viewer.transactionByHash(submissionHash)
 
       // Transaction found on chain
       if (isDefined(foundTx) && !isNull(foundTx)) {
         await job.log(`[${hash}] Found transaction on chain`)
-        // TODO: For now we just store the same hash as TX hash until we have block hash confirmation capability
-        state.confirmationHash = hash
+        // Store the block hash
+        state.confirmationHash = await PayloadBuilder.hash(foundTx[0])
         await stateMap.set(hash, state)
         return {}
       }
@@ -59,8 +61,16 @@ const createWorker = (connection: Redis) => {
     },
     { connection },
   )
+
+  worker.on('failed', (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message)
+  })
+
+  worker.on('error', (err) => {
+    console.error(`[${name}] Worker error:`, err)
+  })
 }
 
-export const xl1TransactionMonitor: WorkerDescription = {
+export const Xl1TransactionMonitor: WorkerDescription = {
   createWorker, name, queueName,
 }

package/src/queue/workers/{xl1TransactionPreparation.ts → Xl1TransactionPreparation.ts}

@@ -1,3 +1,4 @@
+import { assertEx } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
@@ -7,17 +8,19 @@ import type { Redis } from 'ioredis'
 import type { IBridgeServiceCollection } from '../../services/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = Pick<IBridgeServiceCollection, 'xl1TxStateMap'> & { tx: SignedHydratedTransaction }
+type JobData = { tx: SignedHydratedTransaction }
 
 interface ReturnType {}
 
 const name = 'Prepare XL1 Transaction'
 const queueName = 'xl1-tx-prepare'
-const createWorker = (connection: Redis) => {
-  new Worker(
+const createWorker = (connection: Redis, services?: IBridgeServiceCollection) => {
+  const stateMap = assertEx(services?.xl1TxStateMap, () => 'xl1TxStateMap service not provided')
+
+  const worker = new Worker(
     queueName,
     async (job: Job<JobData, ReturnType>) => {
-      const { tx, xl1TxStateMap: stateMap } = job.data
+      const { tx } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       await job.log(`[${hash}] preparing XL1 transaction`)
       const preparedTx = tx
@@ -29,8 +32,16 @@ const createWorker = (connection: Redis) => {
     },
     { connection },
   )
+
+  worker.on('failed', (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message)
+  })
+
+  worker.on('error', (err) => {
+    console.error(`[${name}] Worker error:`, err)
+  })
 }
 
-export const xl1TransactionPreparation: WorkerDescription = {
+export const Xl1TransactionPreparation: WorkerDescription = {
   createWorker, name, queueName,
 }

package/src/queue/workers/{xl1TransactionSubmission.ts → Xl1TransactionSubmission.ts}

@@ -1,14 +1,15 @@
 import { assertEx, isDefined } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+import { type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { Redis } from 'ioredis'
 
 import type { IBridgeServiceCollection, Xl1TxState } from '../../services/index.ts'
+import { submitXl1Transaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
 
-type JobData = Pick<IBridgeServiceCollection, 'gateway' | 'xl1TxStateMap'> & { tx: SignedHydratedTransaction }
+type JobData = { tx: SignedHydratedTransaction }
 
 interface ReturnType {
   submissionHash: Required<Xl1TxState>['submissionHash']
@@ -16,13 +17,14 @@ interface ReturnType {
 
 const name = 'Submit XL1 Transaction'
 const queueName = 'xl1-tx-submit'
-const createWorker = (connection: Redis) => {
-  new Worker(
+const createWorker = (connection: Redis, services?: IBridgeServiceCollection) => {
+  const gateway = assertEx(services?.gateway, () => 'gateway service not provided')
+  const stateMap = assertEx(services?.xl1TxStateMap, () => 'xl1TxStateMap service not provided')
+
+  const worker = new Worker(
     queueName,
     async (job: Job<JobData, ReturnType>) => {
-      const {
-        gateway, tx, xl1TxStateMap: stateMap,
-      } = job.data
+      const { tx } = job.data
       // Get the hash of the transaction
       const hash = await PayloadBuilder.hash(tx[0])
       // Get the state of the transaction
@@ -38,9 +40,10 @@ const createWorker = (connection: Redis) => {
 
       // Submit the transaction to the XL1 network
       await job.log(`[${hash}] Submitting XL1 tx`)
-      const [submissionHash] = await gateway.addTransactionToChain(preparedTx)
+      const [submissionHash] = await submitXl1Transaction(preparedTx, gateway)
+
       // Ensure the submission hash matches the expected hash
-      assertEx(submissionHash === hash, () => `[${hash}] Submitted transaction hash ${submissionHash} does not match expected hash`)
+      // assertEx(submissionHash === hash, () => `[${hash}] Submitted transaction hash ${submissionHash} does not match expected hash`)
       await job.log(`[${hash}] Submitted XL1 tx`)
 
       // Store the submission hash in the state
@@ -53,8 +56,16 @@ const createWorker = (connection: Redis) => {
     },
     { connection },
   )
+
+  worker.on('failed', (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message)
+  })
+
+  worker.on('error', (err) => {
+    console.error(`[${name}] Worker error:`, err)
+  })
 }
 
-export const xl1TransactionSubmission: WorkerDescription = {
+export const Xl1TransactionSubmission: WorkerDescription = {
   createWorker, name, queueName,
 }

package/src/queue/workers/createWorkers.ts

@@ -1,15 +1,22 @@
 import type { Redis } from 'ioredis'
 
+import type { IBridgeServiceCollection } from '../../services/index.ts'
 import {
-  ethTransactionMonitor, ethTransactionSubmission, xl1ToEthBridgeParent, xl1TransactionMonitor, xl1TransactionSubmission,
+  EthTransactionMonitor,
+  EthTransactionPreparation,
+  EthTransactionSubmission,
+  Xl1ToEthBridgeParent,
+  Xl1TransactionMonitor,
+  Xl1TransactionPreparation,
+  Xl1TransactionSubmission,
 } from './index.ts'
 
-export const createWorkers = (connection: Redis) => {
-  return [
-    xl1ToEthBridgeParent.createWorker(connection),
-    xl1TransactionSubmission.createWorker(connection),
-    xl1TransactionMonitor.createWorker(connection),
-    ethTransactionSubmission.createWorker(connection),
-    ethTransactionMonitor.createWorker(connection),
-  ]
+export const createWorkers = (connection: Redis, services: IBridgeServiceCollection) => {
+  Xl1ToEthBridgeParent.createWorker(connection)
+  Xl1TransactionPreparation.createWorker(connection, services)
+  Xl1TransactionSubmission.createWorker(connection, services)
+  Xl1TransactionMonitor.createWorker(connection, services)
+  EthTransactionPreparation.createWorker(connection, services)
+  EthTransactionSubmission.createWorker(connection, services)
+  EthTransactionMonitor.createWorker(connection, services)
 }

package/src/queue/workers/index.ts

@@ -1,8 +1,8 @@
 export * from './createWorkers.ts'
-export * from './ethTransactionMonitor.ts'
-export * from './ethTransactionPreparation.ts'
-export * from './ethTransactionSubmission.ts'
-export * from './xl1ToEthBridgeParent.ts'
-export * from './xl1TransactionMonitor.ts'
-export * from './xl1TransactionPreparation.ts'
-export * from './xl1TransactionSubmission.ts'
+export * from './EthTransactionMonitor.ts'
+export * from './EthTransactionPreparation.ts'
+export * from './EthTransactionSubmission.ts'
+export * from './Xl1ToEthBridgeParent.ts'
+export * from './Xl1TransactionMonitor.ts'
+export * from './Xl1TransactionPreparation.ts'
+export * from './Xl1TransactionSubmission.ts'

package/src/queue/workers/util/index.ts

@@ -0,0 +1,2 @@
+export * from './submitEthTransaction.ts'
+export * from './submitXl1Transaction.ts'

package/src/queue/workers/util/submitEthTransaction.ts

@@ -0,0 +1,25 @@
+import {
+  assertEx, hexToBigInt, toEthAddress,
+} from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
+import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+import type { Wallet } from 'ethers'
+
+export const submitEthTransaction = async (tx: SignedHydratedTransaction, bridgeableToken: BridgeableToken, bridge: LiquidityPoolBridge, wallet: Wallet) => {
+  // Approve the bridge to spend tokens
+  const xl1Transaction = assertEx(tx[0], () => 'No corresponding XL1 transaction found')
+  const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')
+  const srcAddress = toEthAddress(bridgeIntent.srcAddress)
+  const destAddress = toEthAddress(bridgeIntent.destAddress)
+  const amount = hexToBigInt(bridgeIntent.destAmount)
+  const nonce = hexToBigInt(await PayloadBuilder.hash(xl1Transaction))
+  // Assume approval has already been done out of band for simplicity
+  // const contractApprovalTx = await bridgeableToken.connect(wallet).approve(bridge.getAddress(), amount)
+  // await contractApprovalTx.wait(1)
+
+  // Send tokens to bridge
+  const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce)
+  const receipt = await bridgeTx.wait(1)
+  return receipt?.hash
+}

package/src/queue/workers/util/submitXl1Transaction.ts

@@ -0,0 +1,9 @@
+import type { SignedHydratedTransaction, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import { isAllowedBlockPayload } from '@xyo-network/xl1-sdk'
+
+export const submitXl1Transaction = async (preparedTx: SignedHydratedTransaction, gateway: XyoGatewayRunner) => {
+  const onChain = preparedTx[1].filter(isAllowedBlockPayload)
+  const offChainPayloads = preparedTx[1].filter(p => !isAllowedBlockPayload(p))
+  const result = await gateway.addPayloadsToChain(onChain, offChainPayloads)
+  return result
+}

package/src/server/addWorkers.ts

@@ -0,0 +1,9 @@
+import type { Config } from '@xyo-network/xl1-sdk'
+
+import { createWorkers, getConnection } from '../queue/index.ts'
+import type { IBridgeServiceCollection } from '../services/index.ts'
+
+export const addWorkers = (config: Config, services: IBridgeServiceCollection) => {
+  const connection = getConnection(config)
+  createWorkers(connection, services)
+}

package/src/server/app.ts

@@ -9,7 +9,7 @@ import cors from 'cors'
 import type { Express } from 'express'
 import express from 'express'
 
-import { addFlowProducer } from './flowProducer.ts'
+import { addFlowProducer } from './addFlowProducer.ts'
 import { addInstrumentation } from './instrumentation.ts'
 import { addRoutes } from './routes/index.ts'
 

package/src/server/index.ts

@@ -4,7 +4,7 @@ export * from './server.ts'
 import type { NodeInstance } from '@xyo-network/node-model'
 import type { FlowProducer } from 'bullmq'
 
-import type { IBridgeServiceCollection } from '../services/index.ts'
+// import type { IBridgeServiceCollection } from '../services/index.ts'
 
 declare global {
   // eslint-disable-next-line @typescript-eslint/no-namespace
@@ -12,7 +12,7 @@ declare global {
     interface Application {
       flowProducer: FlowProducer
       node: NodeInstance
-      services: IBridgeServiceCollection
+      // services: IBridgeServiceCollection
     }
   }
 }

package/src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts

@@ -1,12 +1,14 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
 import { BridgeSettingsZod, type Config } from '@xyo-network/xl1-sdk'
+import type { z } from 'zod'
 
 import { getBridgeSettings } from '../../../../../config/index.ts'
 
-const response = BridgeSettingsZod
+export const BridgeConfigResponseZod = BridgeSettingsZod
+export type BridgeConfigResponse = z.infer<typeof BridgeConfigResponseZod>
 
-const validateRequest = requestHandlerValidator({ response })
+const validateRequest = requestHandlerValidator({ response: BridgeConfigResponseZod })
 
 export const makeBridgeConfigRoute = (config: Config): RouteDefinition => {
   return {

package/src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts

@@ -1,10 +1,9 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
+import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
 import type {
-  BridgeSourceObservation, BridgeSourceObservationFields, Config,
-  SignedHydratedTransaction,
+  BridgeSourceObservation, BridgeSourceObservationFields, Config, SignedHydratedTransaction,
 } from '@xyo-network/xl1-sdk'
 import {
   BridgeIntentFieldsZod, BridgeIntentSchema, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod, TransferZod,
@@ -15,17 +14,21 @@ import { createXl1ToEthBridgeJob } from '../../../../../queue/index.ts'
 import { validateBridgeEstimateExact, validateBridgeTransaction } from '../../../../../util/index.ts'
 import { getRemoteChainIdZod } from '../pathParams/index.ts'
 
+export const BridgeToRemoteBodyZod = z.tuple([
+  SignedTransactionBoundWitnessZod,
+  PayloadZodLooseOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+  TransferZod,
+])
+export type BridgeToRemoteBody = z.infer<typeof BridgeToRemoteBodyZod>
+
+export const BridgeToRemoteResponseZod = PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape)
+export type BridgeToRemoteResponse = z.infer<typeof BridgeToRemoteResponseZod>
+
 export const makeBridgeToRemoteRoute = (config: Config): RouteDefinition => {
   const params = z.object({ chainId: getRemoteChainIdZod(config) })
-  const body = z.tuple([
-    SignedTransactionBoundWitnessZod,
-    PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-    TransferZod,
-  ])
-  const response = PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape)
 
   const validateRequest = requestHandlerValidator({
-    params, body, response,
+    params, body: BridgeToRemoteBodyZod, response: BridgeToRemoteResponseZod,
   })
   return {
     method: 'post',

package/src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts

@@ -1,10 +1,12 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
 import { assertEx, toAddress } from '@xylabs/sdk-js'
-import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
-import { buildUnsignedTransaction, type Config } from '@xyo-network/xl1-sdk'
+import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
 import {
-  BridgeIntentFieldsZod, BridgeIntentSchema, toXL1BlockNumber, TransactionBoundWitnessZod, TransferSchema,
+  buildUnsignedTransaction, type Config, TransferZod,
+} from '@xyo-network/xl1-sdk'
+import {
+  BridgeIntentFieldsZod, BridgeIntentSchema, toXL1BlockNumber, TransactionBoundWitnessZod,
 } from '@xyo-network/xl1-sdk'
 import { z } from 'zod'
 
@@ -12,22 +14,26 @@ import { getGateway, getXl1ChainId } from '../../../../../config/index.ts'
 import { generateBridgeEstimate } from '../../../../../util/index.ts'
 import { getRemoteChainIdZod } from '../pathParams/index.ts'
 
+export const BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod.pick({
+  destAddress: true,
+  srcAddress: true,
+  srcAmount: true,
+})
+export type BridgeToRemoteEstimateBody = z.infer<typeof BridgeToRemoteEstimateBodyZod>
+
+export const BridgeToRemoteEstimateResponseZod = z.tuple([
+  TransactionBoundWitnessZod,
+  PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+  TransferZod,
+])
+
+export type BridgeToRemoteEstimateResponse = z.infer<typeof BridgeToRemoteEstimateResponseZod>
+
 export const makeBridgeToRemoteEstimateRoute = (config: Config): RouteDefinition => {
   const params = z.object({ chainId: getRemoteChainIdZod(config) })
-  const body = BridgeIntentFieldsZod.pick({
-    destAddress: true,
-    srcAddress: true,
-    srcAmount: true,
-  })
-  const response = z.tuple([
-    TransactionBoundWitnessZod,
-    PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-    PayloadZodLooseOfSchema(TransferSchema),
-  ])
   const validateRequest = requestHandlerValidator({
-    params, body, response,
+    params, body: BridgeToRemoteEstimateBodyZod, response: BridgeToRemoteEstimateResponseZod,
   })
-
   return {
     method: 'post',
     path: '/bridge/chains/:chainId/bridgeToRemote/estimate',

package/src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts

@@ -17,28 +17,30 @@ import { getBridgeSettings } from '../../../../../config/index.ts'
 import { generateBridgeEstimate } from '../../../../../util/index.ts'
 import { getRemoteChainIdZod } from '../pathParams/index.ts'
 
+export const BridgeToRemoteStatusResponseZod = z.union([
+  z.tuple([]),
+  z.tuple([PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape)]),
+  z.tuple([
+    PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+    PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape),
+  ]),
+  z.tuple([
+    PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+    PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape),
+    PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape),
+  ]),
+])
+export type BridgeToRemoteStatusResponse = z.infer<typeof BridgeToRemoteStatusResponseZod>
+
 export const makeBridgeToRemoteStatusRoute = (config: Config): RouteDefinition => {
   const params = z.object({
     chainId: getRemoteChainIdZod(config),
     nonce: z.string().nonempty(),
   })
   const query = z.object({ mockStatus: z.coerce.number().default(0) })
-  const response = z.union([
-    z.tuple([]),
-    z.tuple([PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape)]),
-    z.tuple([
-      PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-      PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape),
-    ]),
-    z.tuple([
-      PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-      PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape),
-      PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape),
-    ]),
-  ])
 
   const validateRequest = requestHandlerValidator({
-    params, query, response,
+    params, query, response: BridgeToRemoteStatusResponseZod,
   })
 
   return {
@@ -47,7 +49,7 @@ export const makeBridgeToRemoteStatusRoute = (config: Config): RouteDefinition =
     handlers: validateRequest(async (req, res) => {
       const { chainId } = req.params
       const { mockStatus = 0 } = req.query
-      const result: z.infer<typeof response> = [] as unknown as z.infer<typeof response>
+      const result: z.infer<typeof BridgeToRemoteStatusResponseZod> = [] as unknown as z.infer<typeof BridgeToRemoteStatusResponseZod>
 
       const {
         remoteTokenAddress, xl1ChainId, xl1TokenAddress,