@xyo-network/chain-bridge 1.20.4 → 1.20.8

package/src/queue/flows/createXl1ToEthBridgeJob/createXl1ToEthBridgeJob.ts

@@ -1,6 +1,18 @@
+import type { Payload } from '@xyo-network/sdk-js'
 import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { FlowProducer } from 'bullmq'
 
+import type {
+  EthTransactionMonitorJobData,
+  EthTransactionPreparationJobData,
+  EthTransactionSubmissionJobData,
+  EthTransactionSubmissionStorageJobData,
+  Xl1ToEthBridgeParentJobData,
+  Xl1TransactionMonitorJobData,
+  Xl1TransactionPreparationJobData,
+  Xl1TransactionSubmissionJobData,
+  Xl1TransactionSubmissionStorageJobData,
+} from '../../workers/index.ts'
 import {
   EthTransactionMonitor, EthTransactionPreparation, EthTransactionSubmission, EthTransactionSubmissionStorage, Xl1ToEthBridgeParent, Xl1TransactionMonitor,
   Xl1TransactionPreparation, Xl1TransactionSubmission, Xl1TransactionSubmissionStorage,
@@ -11,25 +23,27 @@ import { getJobIdForXl1ToEthBridgeJob } from './getJobIdForXl1ToEthBridgeJob.ts'
  * Creates a job flow for bridging a transaction from XL1 to Ethereum.
  * @param flowProducer The flow producer to run the job
  * @param tx The bridge transaction
+ * @param offChainPayloads The payloads to put off chain
  * @returns The JobNode representing the XL1 to ETH bridge job
  */
 export const createXl1ToEthBridgeJob = async (
   flowProducer: FlowProducer,
   tx: SignedHydratedTransaction,
+  offChainPayloads: Payload[] = [],
 ) => {
   const jobId = await getJobIdForXl1ToEthBridgeJob(tx)
   const flow = await flowProducer.add({
     // Step 0 (runs first as parent job)
     name: Xl1ToEthBridgeParent.name,
     queueName: Xl1ToEthBridgeParent.queueName,
-    data: { tx },
+    data: { tx, offChainPayloads } as Xl1ToEthBridgeParentJobData,
     opts: { jobId },
     children: [
       {
         // Step 8
         name: EthTransactionMonitor.name,
         queueName: EthTransactionMonitor.queueName,
-        data: { tx },
+        data: { tx } as EthTransactionMonitorJobData,
         opts: {
           jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
         },
@@ -38,7 +52,7 @@ export const createXl1ToEthBridgeJob = async (
             // Step 7
             name: EthTransactionSubmissionStorage.name,
             queueName: EthTransactionSubmissionStorage.queueName,
-            data: { tx },
+            data: { tx } as EthTransactionSubmissionStorageJobData,
             opts: {
               jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
             },
@@ -47,14 +61,14 @@ export const createXl1ToEthBridgeJob = async (
                 // Step 6
                 name: EthTransactionSubmission.name,
                 queueName: EthTransactionSubmission.queueName,
-                data: { tx },
+                data: { tx, offChainPayloads } as EthTransactionSubmissionJobData,
                 opts: { jobId },
                 children: [
                   {
                     // Step 5
                     name: EthTransactionPreparation.name,
                     queueName: EthTransactionPreparation.queueName,
-                    data: { tx },
+                    data: { tx, offChainPayloads } as EthTransactionPreparationJobData,
                     opts: {
                       jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
                     },
@@ -63,7 +77,7 @@ export const createXl1ToEthBridgeJob = async (
                         // Step 4
                         name: Xl1TransactionMonitor.name,
                         queueName: Xl1TransactionMonitor.queueName,
-                        data: { tx },
+                        data: { tx } as Xl1TransactionMonitorJobData,
                         opts: {
                           jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
                         },
@@ -72,7 +86,7 @@ export const createXl1ToEthBridgeJob = async (
                             // Step 3
                             name: Xl1TransactionSubmissionStorage.name,
                             queueName: Xl1TransactionSubmissionStorage.queueName,
-                            data: { tx },
+                            data: { tx } as Xl1TransactionSubmissionStorageJobData,
                             opts: {
                               jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
                             },
@@ -81,14 +95,14 @@ export const createXl1ToEthBridgeJob = async (
                                 // Step 2
                                 name: Xl1TransactionSubmission.name,
                                 queueName: Xl1TransactionSubmission.queueName,
-                                data: { tx },
+                                data: { tx } as Xl1TransactionSubmissionJobData,
                                 opts: { jobId },
                                 children: [
                                   {
                                     // Step 1 (runs first as deepest child)
                                     name: Xl1TransactionPreparation.name,
                                     queueName: Xl1TransactionPreparation.queueName,
-                                    data: { tx },
+                                    data: { tx, offChainPayloads } as Xl1TransactionPreparationJobData,
                                     opts: {
                                       jobId, attempts: 60, backoff: { type: 'fixed', delay: 5000 },
                                     },

package/src/queue/workers/EthTransactionMonitor.ts

@@ -1,6 +1,5 @@
 import { assertEx } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
@@ -9,8 +8,9 @@ import type { Redis } from 'ioredis'
 import type { IBridgeServiceCollection } from '../../services/index.ts'
 import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
 
-export type EthTransactionMonitorJobData = { tx: SignedHydratedTransaction }
+export type EthTransactionMonitorJobData = Xl1TransactionJobData
 export interface EthTransactionMonitorJobReturn {
   blockHash: string
   blockNumber: number

package/src/queue/workers/EthTransactionPreparation.ts

@@ -1,6 +1,6 @@
 import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
-import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+import { isBridgeIntent } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
@@ -13,8 +13,9 @@ import {
 } from '../../validation/index.ts'
 import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1DataLakeTransactionJobData } from './Xl1TransactionJobData.ts'
 
-export type EthTransactionPreparationJobData = { tx: SignedHydratedTransaction }
+export type EthTransactionPreparationJobData = Xl1DataLakeTransactionJobData
 export type EthTransactionPreparationJobReturn = Record<string, never>
 export type EthTransactionPreparationJob = Job<EthTransactionPreparationJobData, EthTransactionPreparationJobReturn>
 
@@ -30,21 +31,22 @@ export const createWorker = (connection: Redis, telemetry?: BullMQOtel, services
   const worker = new Worker(
     queueName,
     async (job: EthTransactionPreparationJob) => {
-      const { tx } = job.data
+      const { tx, offChainPayloads } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       await job.log(`[${hash}] preparing ETH transaction`)
       await job.log(`[${hash}] validating liquiditySource has sufficient allowance`)
-      if (!await validateSufficientLiquiditySourceAllowance(tx, bridgeableToken, bridge, job)) {
+      if (!await validateSufficientLiquiditySourceAllowance(tx, offChainPayloads, bridgeableToken, bridge, job)) {
         throw new Error('Liquidity source does not have sufficient allowance for the bridge to execute the transaction')
       }
       await job.log(`[${hash}] validated liquiditySource has sufficient allowance`)
       await job.log(`[${hash}] validating liquiditySource has sufficient balance`)
-      if (!await validateSufficientLiquiditySourceBalance(tx, bridgeableToken, bridge, job)) {
+      if (!await validateSufficientLiquiditySourceBalance(tx, offChainPayloads, bridgeableToken, bridge, job)) {
         throw new Error('Liquidity source does not have sufficient balance for the bridge to execute the transaction')
       }
       await job.log(`[${hash}] validated liquiditySource has sufficient balance`)
       await job.log(`[${hash}] building ETH transaction`)
-      const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')
+      const allPayloads = [...tx[1], ...offChainPayloads]
+      const bridgeIntent = assertEx(allPayloads.find(isBridgeIntent), () => 'No bridge intent found')
       const amount = hexToBigInt(bridgeIntent.destAmount)
       const srcAddress = getAddress(bridgeIntent.srcAddress)
       const destAddress = getAddress(bridgeIntent.destAddress)

package/src/queue/workers/EthTransactionSubmission.ts

@@ -1,6 +1,5 @@
 import { assertEx, isDefined } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
-import { type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
@@ -10,8 +9,9 @@ import type { EthTxState, IBridgeServiceCollection } from '../../services/index.
 import { prefix } from '../prefix.ts'
 import { submitEthTransaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1DataLakeTransactionJobData } from './Xl1TransactionJobData.ts'
 
-export type EthTransactionSubmissionJobData = { tx: SignedHydratedTransaction }
+export type EthTransactionSubmissionJobData = Xl1DataLakeTransactionJobData
 export interface EthTransactionSubmissionJobReturn {
   submissionHash: Required<EthTxState>['submissionHash']
 }
@@ -21,14 +21,13 @@ const name = 'Submit ETH Transaction'
 const queueName = 'eth-tx-submit'
 const createWorker = (connection: Redis, telemetry?: BullMQOtel, 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: EthTransactionSubmissionJob) => {
-      const { tx } = job.data
+      const { tx, offChainPayloads } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
 
@@ -41,7 +40,7 @@ const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBri
 
       // Submit the transaction to the Ethereum network
       await job.log(`[${hash}] Submitting ETH tx`)
-      const submissionHash = assertEx(await submitEthTransaction(tx, bridgeableToken, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`)
+      const submissionHash = assertEx(await submitEthTransaction(tx, offChainPayloads, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`)
       await job.log(`[${hash}] Submitted ETH tx and received submission response hash ${submissionHash}`)
       return { submissionHash }
     },

package/src/queue/workers/EthTransactionSubmissionStorage.ts

@@ -1,6 +1,5 @@
 import { assertEx, isDefined } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
@@ -11,8 +10,9 @@ import { prefix } from '../prefix.ts'
 import type { EthTransactionSubmissionJobReturn } from './EthTransactionSubmission.ts'
 import { EthTransactionSubmission } from './EthTransactionSubmission.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
 
-export type EthTransactionSubmissionStorageJobData = { tx: SignedHydratedTransaction }
+export type EthTransactionSubmissionStorageJobData = Xl1TransactionJobData
 export interface EthTransactionSubmissionStorageJobReturn {
   submissionHash: Required<EthTxState>['submissionHash']
 }

package/src/queue/workers/Xl1ToEthBridgeParent.ts

@@ -1,4 +1,3 @@
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
@@ -6,8 +5,9 @@ import type { Redis } from 'ioredis'
 
 import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1DataLakeTransactionJobData } from './Xl1TransactionJobData.ts'
 
-export type Xl1ToEthBridgeParentJobData = { tx: SignedHydratedTransaction }
+export type Xl1ToEthBridgeParentJobData = Xl1DataLakeTransactionJobData
 export interface Xl1ToEthBridgeParentJobReturn { }
 export type Xl1ToEthBridgeParentJob = Job<Xl1ToEthBridgeParentJobData, Xl1ToEthBridgeParentJobReturn>
 

package/src/queue/workers/Xl1TransactionJobData.ts

@@ -0,0 +1,12 @@
+import type { Payload } from '@xyo-network/sdk-js'
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+
+/**
+ * Represents the data required for a job that requires an XL1 transaction.
+ */
+export type Xl1TransactionJobData = { tx: SignedHydratedTransaction }
+
+/**
+ * Represents the data required for a job that requires an XL1 transaction and its associated off-chain payloads.
+ */
+export type Xl1DataLakeTransactionJobData = Xl1TransactionJobData & { offChainPayloads: Payload[] }

package/src/queue/workers/Xl1TransactionMonitor.ts

@@ -3,7 +3,6 @@ import {
   assertEx, isDefined, isNull,
 } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { UnrecoverableError, Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
@@ -12,8 +11,9 @@ import type { Redis } from 'ioredis'
 import type { IBridgeServiceCollection } from '../../services/index.ts'
 import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
 
-export type Xl1TransactionMonitorJobData = { tx: SignedHydratedTransaction }
+export type Xl1TransactionMonitorJobData = Xl1TransactionJobData
 export interface Xl1TransactionMonitorJobReturn {
   submissionHash: BrandedHash
 }

package/src/queue/workers/Xl1TransactionPreparation.ts

@@ -9,8 +9,9 @@ import type { Redis } from 'ioredis'
 import type { IBridgeServiceCollection } from '../../services/index.ts'
 import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1DataLakeTransactionJobData } from './Xl1TransactionJobData.ts'
 
-export type Xl1TransactionPreparationJobData = { tx: SignedHydratedTransaction }
+export type Xl1TransactionPreparationJobData = Xl1DataLakeTransactionJobData
 export interface Xl1TransactionPreparationJobReturn { preparedTx: SignedHydratedTransaction }
 export type Xl1TransactionPreparationJob = Job<Xl1TransactionPreparationJobData, Xl1TransactionPreparationJobReturn>
 
@@ -22,12 +23,12 @@ const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBri
   const worker = new Worker(
     queueName,
     async (job: Xl1TransactionPreparationJob) => {
-      const { tx } = job.data
+      const { tx, offChainPayloads = [] } = job.data
       const hash = await PayloadBuilder.hash(tx[0])
       await job.log(`[${hash}] preparing XL1 transaction`)
       const preparedTx = tx
       await job.log(`[${hash}] storing XL1 preparedTx`)
-      await stateMap.set(hash, { preparedTx })
+      await stateMap.set(hash, { offChainPayloads, preparedTx })
       await job.log(`[${hash}] stored XL1 preparedTx`)
       await job.log(`[${hash}] prepared XL1 transaction`)
       return { preparedTx }

package/src/queue/workers/Xl1TransactionSubmission.ts

@@ -1,6 +1,5 @@
 import { assertEx, isDefined } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
-import { type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
@@ -10,8 +9,9 @@ import type { IBridgeServiceCollection, Xl1TxState } from '../../services/index.
 import { prefix } from '../prefix.ts'
 import { submitXl1Transaction } from './util/index.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
 
-export type Xl1TransactionSubmissionJobData = { tx: SignedHydratedTransaction }
+export type Xl1TransactionSubmissionJobData = Xl1TransactionJobData
 export interface Xl1TransactionSubmissionJobReturn {
   submissionHash: Required<Xl1TxState>['submissionHash']
 }
@@ -32,21 +32,20 @@ const createWorker = (connection: Redis, telemetry?: BullMQOtel, services?: IBri
       const hash = await PayloadBuilder.hash(tx[0])
       // Get the state of the transaction
       const state = assertEx(await stateMap.get(hash), () => `[${hash}] state not found`)
-      const preparedTx = assertEx(state?.preparedTx, () => `[${hash}] preparedTx not found`)
+      const {
+        preparedTx, offChainPayloads = [], submissionHash: existingSubmissionHash,
+      } = state
 
       // Idempotency check against resubmission
-      const { submissionHash: existingSubmissionHash } = state
       if (isDefined(existingSubmissionHash)) {
         await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`)
         return { submissionHash: existingSubmissionHash }
       }
+      const txToSubmit = assertEx(preparedTx, () => `[${hash}] preparedTx not found`)
 
       // Submit the transaction to the XL1 network
       await job.log(`[${hash}] Submitting XL1 tx`)
-      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`)
+      const [submissionHash] = await submitXl1Transaction(txToSubmit, offChainPayloads, gateway)
       await job.log(`[${hash}] Submitted XL1 tx`)
 
       // This worker intentionally does NOT store state as subsequent steps will do that.

package/src/queue/workers/Xl1TransactionSubmissionStorage.ts

@@ -1,6 +1,5 @@
 import { assertEx, isDefined } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
-import { type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'
 import type { BullMQOtel } from 'bullmq-otel'
@@ -9,10 +8,11 @@ import type { Redis } from 'ioredis'
 import type { IBridgeServiceCollection, Xl1TxState } from '../../services/index.ts'
 import { prefix } from '../prefix.ts'
 import type { WorkerDescription } from './WorkerDescription.ts'
+import type { Xl1TransactionJobData } from './Xl1TransactionJobData.ts'
 import type { Xl1TransactionSubmissionJobReturn } from './Xl1TransactionSubmission.ts'
 import { Xl1TransactionSubmission } from './Xl1TransactionSubmission.ts'
 
-export type Xl1TransactionSubmissionStorageJobData = { tx: SignedHydratedTransaction }
+export type Xl1TransactionSubmissionStorageJobData = Xl1TransactionJobData
 export interface Xl1TransactionSubmissionStorageJobReturn {
   submissionHash: Required<Xl1TxState>['submissionHash']
 }

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

@@ -1,15 +1,22 @@
 import {
   assertEx, hexToBigInt, toEthAddress,
 } from '@xylabs/sdk-js'
+import type { Payload } from '@xyo-network/sdk-js'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
+import type { 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) => {
+export const submitEthTransaction = async (
+  tx: SignedHydratedTransaction,
+  offChainPayloads: Payload[],
+  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 allPayloads = [...tx[1], ...offChainPayloads]
+  const bridgeIntent = assertEx(allPayloads.find(isBridgeIntent), () => 'No bridge intent found')
   const srcAddress = toEthAddress(bridgeIntent.srcAddress)
   const destAddress = toEthAddress(bridgeIntent.destAddress)
   const amount = hexToBigInt(bridgeIntent.destAmount)

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

@@ -1,10 +1,10 @@
 import { type BrandedHash } from '@xylabs/sdk-js'
-import {
-  isAllowedBlockPayload, type SignedHydratedTransaction, type XyoGatewayRunner,
-} from '@xyo-network/xl1-sdk'
+import type { Payload } from '@xyo-network/sdk-js'
+import { type SignedHydratedTransaction, type XyoGatewayRunner } from '@xyo-network/xl1-sdk'
 
 export const submitXl1Transaction = async (
   preparedTx: SignedHydratedTransaction,
+  offChain: Payload[] = [],
   gateway: XyoGatewayRunner,
 ): Promise<[BrandedHash, SignedHydratedTransaction]> => {
   // Option 1: Add payloads to chain with addPayloadsToChain
@@ -16,8 +16,7 @@ export const submitXl1Transaction = async (
 
   // Option 2: Add transaction to chain with addTransactionToChain
   // Fails due to resigning of transaction in addTransactionToChain, which causes `from` to be invalid
-  const offChainPayloads = preparedTx[1].filter(p => !isAllowedBlockPayload(p))
-  const result = await gateway.addTransactionToChain(preparedTx, offChainPayloads)
+  const result = await gateway.addTransactionToChain(preparedTx, offChain)
   return result
 
   // Option 3: Add transaction to chain with addTransactionToChain, but bypass resigning by passing the preparedTx as an unsigned transaction

package/src/server/app.ts

@@ -1,11 +1,7 @@
-import {
-  customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler,
-  standardErrors, standardResponses,
-} from '@xylabs/express'
+import { standardErrors } from '@xylabs/express'
 import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import { sharedMiddleware } from '@xyo-network/chain-orchestration'
 import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-import compression from 'compression'
-import cors from 'cors'
 import type { Express } from 'express'
 import express from 'express'
 
@@ -16,15 +12,7 @@ import { addRoutes } from './routes/index.ts'
 export const getApp = (config: BridgeConfig, gateway: XyoGatewayRunner): Express => {
   addInstrumentation()
   const app = express()
-  app.set('etag', false)
-  app.use(cors())
-  app.use(compression())
-  app.use(responseProfiler)
-  app.use(getJsonBodyParser(getJsonBodyParserOptions({ limit: '1mb' })))
-  app.use(standardResponses)
-  disableExpressDefaultPoweredByHeader(app)
-  app.use(customPoweredByHeader)
-  disableCaseSensitiveRouting(app)
+  sharedMiddleware(app)
   addFlowProducer(app, config)
   addRoutes(app, config, gateway)
   app.use(standardErrors)

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

@@ -65,7 +65,7 @@ export const makeBridgeToRemoteRoute = (config: BridgeConfig): RouteDefinition =
       }
 
       // Create the signed hydrated transaction for the job
-      const singedHydratedTransaction: SignedHydratedTransaction = [signedTxBw, [transfer, bridgeIntent]]
+      const singedHydratedTransaction: SignedHydratedTransaction = [signedTxBw, [transfer]]
 
       // Check if a job already exists for this transaction
       const existingFlow = await getXl1ToEthBridgeJob(flowProducer, singedHydratedTransaction)
@@ -75,7 +75,7 @@ export const makeBridgeToRemoteRoute = (config: BridgeConfig): RouteDefinition =
       }
 
       // Submit to job queue
-      await createXl1ToEthBridgeJob(flowProducer, singedHydratedTransaction)
+      await createXl1ToEthBridgeJob(flowProducer, singedHydratedTransaction, [bridgeIntent])
 
       // Create BridgeObservation
       const srcConfirmation = await PayloadBuilder.hash(signedTxBw)

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

@@ -49,13 +49,14 @@ export const makeBridgeToRemoteStatusRoute = (config: BridgeConfig): RouteDefini
       const statusQueueJobs = await getStatusQueueJobs(queues, jobId)
 
       // Check for the transaction hash in the parent job
-      const tx = statusQueueJobs.xl1ToEthBridgeParentJob?.data?.tx
+      const { tx, offChainPayloads = [] } = statusQueueJobs.xl1ToEthBridgeParentJob?.data ?? {}
 
       // If the job does not exist return Not Found
       if (!tx) return res.sendStatus(404)
 
       // If the tx is not the right shape for bridging return Not Found
-      const bridgeIntent = tx[1].find(isBridgeIntent)
+      const allPayloads = [...tx[1], ...offChainPayloads]
+      const bridgeIntent = allPayloads.find(isBridgeIntent)
       if (!bridgeIntent) return res.sendStatus(404)
 
       // At this point we know we have a valid bridge intent, so we can start building the response

package/src/services/Xl1TxState.ts

@@ -1,6 +1,9 @@
 import type { Hash } from '@xylabs/sdk-js'
+import type { Payload } from '@xyo-network/sdk-js'
 import type { SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 
 import type { TxState } from './TxState.ts'
 
-export interface Xl1TxState extends TxState<SignedHydratedTransaction, Hash, Hash> {}
+export interface Xl1TxState extends TxState<SignedHydratedTransaction, Hash, Hash> {
+  offChainPayloads?: Payload[]
+}

package/src/util/calculateBridgeFees.ts

@@ -13,7 +13,7 @@ export const calculateBridgeFees = (srcAmount: Hex, feeStructure: FeeStructure):
   const srcAmountBigInt = hexToBigInt(srcAmount)
 
   // Calculate fixed fee
-  const feeFixedBigInt = hexToBigInt(feeFixed)
+  // const feeFixedBigInt = hexToBigInt(feeFixed)
 
   // Integer-safe basis point calculation (floor division)
   const feeVariableBigInt
@@ -21,11 +21,11 @@ export const calculateBridgeFees = (srcAmount: Hex, feeStructure: FeeStructure):
   const feeVariable = toHex(feeVariableBigInt)
 
   // Calculate total fee
-  const feeTotalBigInt = feeFixedBigInt + feeVariableBigInt
+  // const feeTotalBigInt = feeFixedBigInt + feeVariableBigInt
 
   // Calculate destination amount
-  const destAmountBigInt = srcAmountBigInt > feeTotalBigInt ? srcAmountBigInt - feeTotalBigInt : 0n
-  const destAmount = toHex(destAmountBigInt)
+  // const destAmountBigInt = srcAmountBigInt > feeTotalBigInt ? srcAmountBigInt - feeTotalBigInt : 0n
+  // const destAmount = toHex(destAmountBigInt)
 
   return {
     feeFixed, feeVariable, srcAmount,

package/src/validation/validateSufficientLiquiditySourceAllowance.ts

@@ -1,4 +1,5 @@
 import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
+import type { Payload } from '@xyo-network/sdk-js'
 import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
 import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 
@@ -9,6 +10,7 @@ import type { AsyncLogger } from './AsyncLogger.ts'
  * ensure that (due to race conditions) the transaction will succeed, but is a quick check to avoid
  * submitting transactions that are likely to fail.
  * @param tx The transaction containing a bridge intent
+ * @param offChainPayloads The payloads to put off chain
  * @param bridgeableToken The contract for the token being bridged
  * @param bridge The contract for the liquidity bridge
  * @param logger Optional logger for asynchronous logging
@@ -16,12 +18,14 @@ import type { AsyncLogger } from './AsyncLogger.ts'
  */
 export const validateSufficientLiquiditySourceAllowance = async (
   tx: SignedHydratedTransaction,
+  offChainPayloads: Payload[],
   bridgeableToken: BridgeableToken,
   bridge: LiquidityPoolBridge,
   logger?: AsyncLogger,
 ) => {
   // Get the amount being bridged from the bridge intent
-  const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')
+  const allPayloads = [...tx[1], ...offChainPayloads]
+  const bridgeIntent = assertEx(allPayloads.find(isBridgeIntent), () => 'No bridge intent found')
   const amount = hexToBigInt(bridgeIntent.destAmount)
 
   // Get the addresses

package/src/validation/validateSufficientLiquiditySourceBalance.ts

@@ -1,4 +1,5 @@
 import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
+import type { Payload } from '@xyo-network/sdk-js'
 import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
 import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 
@@ -9,6 +10,7 @@ import type { AsyncLogger } from './AsyncLogger.ts'
  * ensure that (due to race conditions) the transaction will succeed, but is a quick check to avoid
  * submitting transactions that are likely to fail.
  * @param tx The transaction containing a bridge intent
+ * @param offChainPayloads The payloads to put off chain
  * @param bridgeableToken The contract for the token being bridged
  * @param bridge The contract for the liquidity bridge
  * @param logger Optional logger for asynchronous logging
@@ -16,12 +18,14 @@ import type { AsyncLogger } from './AsyncLogger.ts'
  */
 export const validateSufficientLiquiditySourceBalance = async (
   tx: SignedHydratedTransaction,
+  offChainPayloads: Payload[],
   bridgeableToken: BridgeableToken,
   bridge: LiquidityPoolBridge,
   logger?: AsyncLogger,
 ) => {
   // Get the amount being bridged from the bridge intent
-  const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')
+  const allPayloads = [...tx[1], ...offChainPayloads]
+  const bridgeIntent = assertEx(allPayloads.find(isBridgeIntent), () => 'No bridge intent found')
   const amount = hexToBigInt(bridgeIntent.destAmount)
 
   // Get the addresses