@xyo-network/chain-bridge 1.19.14 → 1.19.16

package/src/queue/workers/Xl1TransactionSubmission.ts

@@ -1,5 +1,5 @@
 import { assertEx, isDefined } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { PayloadBuilder } from '@xyo-network/sdk-js'
 import { type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Job } from 'bullmq'
 import { Worker } from 'bullmq'

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

@@ -1,2 +1,4 @@
 export * from './submitEthTransaction.ts'
 export * from './submitXl1Transaction.ts'
+export * from './validateSufficientAllowance.ts'
+export * from './validateSufficientBalance.ts'

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

@@ -1,7 +1,7 @@
 import {
   assertEx, hexToBigInt, toEthAddress,
 } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { PayloadBuilder } from '@xyo-network/sdk-js'
 import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
 import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
 import type { Wallet } from 'ethers'

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

@@ -0,0 +1,38 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
+import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
+import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+
+interface IAsyncLogger {
+  log: (message: string) => Promisable<unknown>
+}
+
+/**
+ * Checks if the liquidity source has sufficient allowance for the bridge to execute the transaction. This doesn't
+ * 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 bridgeableToken The contract for the token being bridged
+ * @param bridge The contract for the liquidity bridge
+ * @param logger Optional logger for asynchronous logging
+ * @returns True if the liquidity source allowance is sufficient to execute the bridge
+ */
+export const validateSufficientAllowance = async (
+  tx: SignedHydratedTransaction,
+  bridgeableToken: BridgeableToken,
+  bridge: LiquidityPoolBridge,
+  logger?: IAsyncLogger,
+) => {
+  // Get the amount being bridged from the bridge intent
+  const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')
+  const amount = hexToBigInt(bridgeIntent.destAmount)
+
+  // Get the addresses
+  const liquiditySourceAddress = await bridge.liquiditySource()
+  const bridgeAddress = await bridge.getAddress()
+
+  // Check the allowance of the liquidity source for the bridge
+  const remainingAllowance = await bridgeableToken.allowance(liquiditySourceAddress, bridgeAddress)
+  await logger?.log(`Remaining allowance: ${remainingAllowance.toString()}`)
+  return remainingAllowance >= amount
+}

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

@@ -0,0 +1,37 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import { assertEx, hexToBigInt } from '@xylabs/sdk-js'
+import type { BridgeableToken, LiquidityPoolBridge } from '@xyo-network/typechain'
+import { isBridgeIntent, type SignedHydratedTransaction } from '@xyo-network/xl1-sdk'
+
+interface IAsyncLogger {
+  log: (message: string) => Promisable<unknown>
+}
+
+/**
+ * Checks if the liquidity source has sufficient balance for the bridge to execute the transaction. This doesn't
+ * 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 bridgeableToken The contract for the token being bridged
+ * @param bridge The contract for the liquidity bridge
+ * @param logger Optional logger for asynchronous logging
+ * @returns True if the liquidity source balance is sufficient to execute the bridge
+ */
+export const validateSufficientBalance = async (
+  tx: SignedHydratedTransaction,
+  bridgeableToken: BridgeableToken,
+  bridge: LiquidityPoolBridge,
+  logger?: IAsyncLogger,
+) => {
+  // Get the amount being bridged from the bridge intent
+  const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => 'No bridge intent found')
+  const amount = hexToBigInt(bridgeIntent.destAmount)
+
+  // Get the addresses
+  const liquiditySourceAddress = await bridge.liquiditySource()
+
+  // Check the balance of the liquidity source for the bridge
+  const balance = await bridgeableToken.balanceOf(liquiditySourceAddress)
+  await logger?.log(`Remaining balance: ${balance.toString()}`)
+  return balance >= amount
+}

package/src/server/addFlowProducer.ts

@@ -1,9 +1,9 @@
-import type { Config } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
 import type { Express } from 'express'
 
 import { getConnection, getFlowProducer } from '../queue/index.ts'
 
-export const addFlowProducer = (app: Express, config: Config): Express => {
+export const addFlowProducer = (app: Express, config: BridgeConfig): Express => {
   const connection = getConnection(config)
   const flowProducer = getFlowProducer(connection)
   app.flowProducer = flowProducer

package/src/server/addWorkers.ts

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

package/src/server/app.ts

@@ -2,8 +2,8 @@ import {
   customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler,
   standardErrors, standardResponses,
 } from '@xylabs/express'
-import type { NodeInstance } from '@xyo-network/node-model'
-import type { Config, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } 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'
@@ -13,7 +13,7 @@ import { addFlowProducer } from './addFlowProducer.ts'
 import { addInstrumentation } from './instrumentation.ts'
 import { addRoutes } from './routes/index.ts'
 
-export const getApp = (node: NodeInstance, config: Config, gateway: XyoGatewayRunner): Express => {
+export const getApp = (config: BridgeConfig, gateway: XyoGatewayRunner): Express => {
   addInstrumentation()
   const app = express()
   app.set('etag', false)
@@ -25,7 +25,6 @@ export const getApp = (node: NodeInstance, config: Config, gateway: XyoGatewayRu
   disableExpressDefaultPoweredByHeader(app)
   app.use(customPoweredByHeader)
   disableCaseSensitiveRouting(app)
-  app.node = node
   addFlowProducer(app, config)
   addRoutes(app, config, gateway)
   app.use(standardErrors)

package/src/server/index.ts

@@ -1,7 +1,7 @@
 export * from './app.ts'
 export * from './server.ts'
 
-import type { NodeInstance } from '@xyo-network/node-model'
+// import type { NodeInstance } from '@xyo-network/sdk-js'
 import type { FlowProducer } from 'bullmq'
 
 // import type { IBridgeServiceCollection } from '../services/index.ts'
@@ -11,7 +11,7 @@ declare global {
   namespace Express {
     interface Application {
       flowProducer: FlowProducer
-      node: NodeInstance
+      // node: NodeInstance
       // services: IBridgeServiceCollection
     }
   }

package/src/server/routes/addRoutes.ts

@@ -1,8 +1,9 @@
-import type { Config, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
 import type { Express } from 'express'
 
 import { addBridgeRoutes } from './bridge/index.ts'
 
-export const addRoutes = (app: Express, config: Config, gateway: XyoGatewayRunner) => {
+export const addRoutes = (app: Express, config: BridgeConfig, gateway: XyoGatewayRunner) => {
   addBridgeRoutes(app, config, gateway)
 }

package/src/server/routes/bridge/addBridgeRoutes.ts

@@ -1,9 +1,10 @@
-import type { Config, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
 import type { Express } from 'express'
 
 import { getRouteDefinitions } from './routeDefinitions/index.ts'
 
-export const addBridgeRoutes = (app: Express, config: Config, gateway: XyoGatewayRunner) => {
+export const addBridgeRoutes = (app: Express, config: BridgeConfig, gateway: XyoGatewayRunner) => {
   const routeDefinitions = getRouteDefinitions(config, gateway)
   for (const definition of routeDefinitions) {
     app[definition.method](definition.path, definition.handlers)

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

@@ -1,11 +1,12 @@
 import type { RouteDefinition } from '@xylabs/express'
-import type { Config, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
 
 import {
   makeBridgeConfigRoute, makeBridgeFromRemoteStatusRoute, makeBridgeToRemoteEstimateRoute, makeBridgeToRemoteRoute, makeBridgeToRemoteStatusRoute,
 } from './routes/index.ts'
 
-export const getRouteDefinitions = (config: Config, gateway: XyoGatewayRunner): RouteDefinition[] => {
+export const getRouteDefinitions = (config: BridgeConfig, gateway: XyoGatewayRunner): RouteDefinition[] => {
   return [
     makeBridgeConfigRoute(config),
     makeBridgeToRemoteEstimateRoute(config, gateway),

package/src/server/routes/bridge/routeDefinitions/pathParams/ChainIdPathParam.ts

@@ -1,11 +1,12 @@
 import {
   asHex, HexZod, isUndefined,
 } from '@xylabs/sdk-js'
-import type { ChainId, Config } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import type { ChainId } from '@xyo-network/xl1-sdk'
 
 import { getRemoteChainId } from '../../../../../config/index.ts'
 
-export const getRemoteChainIdZod = (config: Config) => {
+export const getRemoteChainIdZod = (config: BridgeConfig) => {
   const remoteChainId: ChainId = getRemoteChainId(config)
   return HexZod.superRefine((val, ctx) => {
     const chainId = asHex(val)

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

@@ -1,6 +1,7 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
-import { BridgeSettingsZod, type Config } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import { BridgeSettingsZod } from '@xyo-network/chain-orchestration'
 import type { z } from 'zod'
 
 import { getBridgeSettings } from '../../../../../config/index.ts'
@@ -10,7 +11,7 @@ export type BridgeConfigResponse = z.infer<typeof BridgeConfigResponseZod>
 
 const validateRequest = requestHandlerValidator({ response: BridgeConfigResponseZod })
 
-export const makeBridgeConfigRoute = (config: Config): RouteDefinition => {
+export const makeBridgeConfigRoute = (config: BridgeConfig): RouteDefinition => {
   return {
     method: 'get',
     path: '/bridge/chains/:chainId/config',

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

@@ -1,8 +1,9 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
 import { toAddress, toHex } from '@xylabs/sdk-js'
-import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
-import type { BridgeDestinationObservation, Config } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import { PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
+import type { BridgeDestinationObservation } from '@xyo-network/xl1-sdk'
 import {
   BridgeDestinationObservationFieldsZod,
   BridgeDestinationObservationSchema,
@@ -12,7 +13,7 @@ import { z } from 'zod'
 import { getBridgeSettings } from '../../../../../config/index.ts'
 import { getRemoteChainIdZod } from '../pathParams/index.ts'
 
-export const makeBridgeFromRemoteStatusRoute = (config: Config): RouteDefinition => {
+export const makeBridgeFromRemoteStatusRoute = (config: BridgeConfig): RouteDefinition => {
   const params = z.object({
     chainId: getRemoteChainIdZod(config),
     nonce: z.string().nonempty(),

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

@@ -1,9 +1,11 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import {
+  PayloadBuilder, PayloadZodLooseOfSchema, PayloadZodStrictOfSchema,
+} from '@xyo-network/sdk-js'
 import type {
-  BridgeSourceObservation, BridgeSourceObservationFields, Config, SignedHydratedTransaction,
+  BridgeSourceObservation, BridgeSourceObservationFields, SignedHydratedTransaction,
 } from '@xyo-network/xl1-sdk'
 import {
   BridgeIntentFieldsZod, BridgeIntentSchema, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod, TransferZod,
@@ -24,7 +26,7 @@ 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 => {
+export const makeBridgeToRemoteRoute = (config: BridgeConfig): RouteDefinition => {
   const params = z.object({ chainId: getRemoteChainIdZod(config) })
 
   const validateRequest = requestHandlerValidator({

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

@@ -1,8 +1,9 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
 import { assertEx, toAddress } from '@xylabs/sdk-js'
-import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
-import type { Config, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import { PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
+import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
 import {
   BridgeIntentFieldsZod, BridgeIntentSchema, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod,
 } from '@xyo-network/xl1-sdk'
@@ -27,7 +28,7 @@ export const BridgeToRemoteEstimateResponseZod = z.tuple([
 
 export type BridgeToRemoteEstimateResponse = z.infer<typeof BridgeToRemoteEstimateResponseZod>
 
-export const makeBridgeToRemoteEstimateRoute = (config: Config, gateway: XyoGatewayRunner): RouteDefinition => {
+export const makeBridgeToRemoteEstimateRoute = (config: BridgeConfig, gateway: XyoGatewayRunner): RouteDefinition => {
   const params = z.object({ chainId: getRemoteChainIdZod(config) })
   const validateRequest = requestHandlerValidator({
     params, body: BridgeToRemoteEstimateBodyZod, response: BridgeToRemoteEstimateResponseZod,

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

@@ -3,10 +3,9 @@ import { requestHandlerValidator } from '@xylabs/express'
 import {
   asAddress, asHex, toHex,
 } from '@xylabs/sdk-js'
-import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
-import type {
-  BridgeDestinationObservation, BridgeSourceObservation, Config,
-} from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import { PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
+import type { BridgeDestinationObservation, BridgeSourceObservation } from '@xyo-network/xl1-sdk'
 import {
   BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema, BridgeIntentFieldsZod, BridgeIntentSchema, BridgeSourceObservationFieldsZod,
   BridgeSourceObservationSchema,
@@ -32,7 +31,7 @@ export const BridgeToRemoteStatusResponseZod = z.union([
 ])
 export type BridgeToRemoteStatusResponse = z.infer<typeof BridgeToRemoteStatusResponseZod>
 
-export const makeBridgeToRemoteStatusRoute = (config: Config): RouteDefinition => {
+export const makeBridgeToRemoteStatusRoute = (config: BridgeConfig): RouteDefinition => {
   const params = z.object({
     chainId: getRemoteChainIdZod(config),
     nonce: z.string().nonempty(),

package/src/server/server.ts

@@ -1,59 +1,18 @@
-import {
-  assertEx, isDefined, isString, type Logger,
-} from '@xylabs/sdk-js'
-import { boot } from '@xyo-network/bios'
-import type { BiosExternalInterface } from '@xyo-network/bios-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-import { HDWallet } from '@xyo-network/wallet'
-import type { Config, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import type { BridgeConfigContext } from '@xyo-network/chain-orchestration'
+import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
 
-import { getNode, getServices } from '../manifest/index.ts'
+import { getServices } from '../services/index.ts'
 import { addWorkers } from './addWorkers.ts'
 import { getApp } from './app.ts'
 
 const hostname = '::'
 // const hostname = '0.0.0.0'
 
-// TODO: Make nodejs version of bios support round tripping mnemonic between boots
-const getSeedPhrase = async (bios: BiosExternalInterface, config: Config, logger?: Logger): Promise<string> => {
-  const storedSeedPhrase = await bios.seedPhraseStore.get('os')
-  logger?.debug(`[Bridge] Stored mnemonic: ${storedSeedPhrase}`)
-  const { mnemonic } = config.actors.api
-  if (isString(storedSeedPhrase) && isString(mnemonic)) {
-    logger?.warn('[Bridge] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.')
-    await bios.seedPhraseStore.set('os', mnemonic)
-  } else {
-    let seedPhrase: string
-    if (isString(mnemonic)) {
-      seedPhrase = mnemonic
-    } else {
-      seedPhrase = HDWallet.generateMnemonic()
-      logger?.log('[Bridge] No mnemonic provided, using random mnemonic. This is not recommended for production use.')
-      logger?.log(`[Bridge] Mnemonic: ${seedPhrase}`)
-    }
-    await bios.seedPhraseStore.set('os', seedPhrase)
-  }
-  return assertEx(await bios.seedPhraseStore.get('os'), () => 'Unable to acquire mnemonic from bios')
-}
-
-interface GetServerContext {
-  config: Config
-  logger?: Logger
-  node?: NodeInstance
-}
-
-export const getServer = async (context: GetServerContext, gateway: XyoGatewayRunner) => {
+export const getServer = async (context: BridgeConfigContext, gateway: XyoGatewayRunner) => {
   const { logger, config } = context
-  const { port, mnemonic } = config.actors.bridge
-  const bios = await boot()
-  const seedPhrase = isDefined(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger)
-  const wallet = await HDWallet.fromPhrase(seedPhrase)
-  const nodeContext = {
-    wallet, logger, config,
-  }
-  const node = context.node ?? await getNode(nodeContext)
-  const app = getApp(node, config, gateway)
-  const services = await getServices({ config, logger }, gateway)
+  const { port } = config
+  const app = getApp(config, gateway)
+  const services = await getServices(context, gateway)
   addWorkers(config, services)
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`))
   server.setTimeout(20_000)

package/src/{manifest → services}/getIterableMap.ts

@@ -1,6 +1,6 @@
 import { BaseMongoSdk, type BaseMongoSdkPrivateConfig } from '@xylabs/mongo'
 import { MongoMap } from '@xyo-network/chain-protocol'
-import type { Config, IterableMap } from '@xyo-network/xl1-sdk'
+import type { BaseConfig, IterableMap } from '@xyo-network/xl1-sdk'
 import { hasMongoConfig, mapToMapType } from '@xyo-network/xl1-sdk'
 import type { Document } from 'mongodb'
 
@@ -11,7 +11,7 @@ import type { Document } from 'mongodb'
  * @returns The iterable map
  */
 export const getIterableMap = async <K extends {} = string, V extends Document = Document>(
-  config: Config,
+  config: BaseConfig,
   collection: string,
 ): Promise<IterableMap<K, V>> => {
   const mongoConfig = config.storage?.mongo

package/src/{manifest → services}/getServices.ts

@@ -1,34 +1,30 @@
-import type { Hash, Logger } from '@xylabs/sdk-js'
+import type { Hash } from '@xylabs/sdk-js'
 import { assertEx, isDefined } from '@xylabs/sdk-js'
+import type { BridgeConfig, BridgeConfigContext } from '@xyo-network/chain-orchestration'
 import { initEvmProvider } from '@xyo-network/chain-orchestration'
 import { BridgeableToken__factory, LiquidityPoolBridge__factory } from '@xyo-network/typechain'
 import { HDWallet } from '@xyo-network/wallet'
-import type { Config, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
 import { getAddress, Wallet } from 'ethers'
 
-import type {
-  EthTxState, IBridgeServiceCollection, Xl1TxState,
-} from '../services/index.ts'
+import type { EthTxState } from './EthTxState.ts'
 import { getIterableMap } from './getIterableMap.ts'
-
-export interface GetServicesContext {
-  config: Config
-  logger?: Logger
-}
+import type { IBridgeServiceCollection } from './IBridgeServiceCollection.ts'
+import type { Xl1TxState } from './Xl1TxState.ts'
 
 /**
  * Used for retrieving a service collection
  * @returns A service collection
  */
-export const getServices = async (context: GetServicesContext, gateway: XyoGatewayRunner): Promise<IBridgeServiceCollection> => {
+export const getServices = async (context: BridgeConfigContext, gateway: XyoGatewayRunner): Promise<IBridgeServiceCollection> => {
   const { config } = context
 
   const ethTxStateMap = await getIterableMap<Hash, EthTxState>(config, 'liquidity_bridge_xl1_to_eth_eth_tx_state')
   const xl1TxStateMap = await getIterableMap<Hash, Xl1TxState>(config, 'liquidity_bridge_xl1_to_eth_xl1_tx_state')
-  const provider = await initEvmProvider({ config })
+  const provider = await initEvmProvider(context)
   const {
     remoteBridgeContractAddress, remoteChainWalletPrivateKey, remoteTokenAddress, mnemonic,
-  } = config.actors.bridge
+  } = config as BridgeConfig
   const account = isDefined(mnemonic) ? await HDWallet.fromPhrase(mnemonic) : await HDWallet.random()
   const wallet = new Wallet(remoteChainWalletPrivateKey, provider)
   const bridgeableToken = BridgeableToken__factory.connect(getAddress(remoteTokenAddress), wallet)

package/src/services/index.ts

@@ -1,4 +1,5 @@
 export * from './EthTxState.ts'
+export * from './getServices.ts'
 export * from './IBridgeServiceCollection.ts'
 export * from './TxState.ts'
 export * from './Xl1TxState.ts'

package/src/util/BridgeFees.ts

@@ -0,0 +1,7 @@
+import type { Hex, JsonObject } from '@xylabs/sdk-js'
+
+export interface BridgeFees extends JsonObject {
+  feeFixed: Hex
+  feeVariable: Hex
+  srcAmount: Hex
+}

package/src/util/bridgeFeesAsBigInt.ts

@@ -0,0 +1,15 @@
+import { hexToBigInt } from '@xylabs/sdk-js'
+
+import type { BridgeFees } from './BridgeFees.ts'
+
+export const bridgeFeesAsBigInt = (fees: BridgeFees): {
+  feeFixed: bigint
+  feeVariable: bigint
+  srcAmount: bigint
+} => {
+  return {
+    feeFixed: hexToBigInt(fees.feeFixed),
+    feeVariable: hexToBigInt(fees.feeVariable),
+    srcAmount: hexToBigInt(fees.srcAmount),
+  }
+}

package/src/util/calculateBridgeFees.ts

@@ -1,16 +1,12 @@
 import type { Hex } from '@xylabs/sdk-js'
 import { hexToBigInt, toHex } from '@xylabs/sdk-js'
-import type { Config } from '@xyo-network/xl1-sdk'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
 
-export type FeeStructure = Pick<Config['actors']['bridge'], 'feeFixed' | 'feeRateBasisPoints'>
+import type { BridgeFees } from './BridgeFees.ts'
 
-export interface FeeCalculationResult {
-  destAmount: Hex
-  feeFixed: Hex
-  feeVariable: Hex
-}
+export type FeeStructure = Pick<BridgeConfig, 'feeFixed' | 'feeRateBasisPoints'>
 
-export const calculateBridgeFees = (srcAmount: Hex, feeStructure: FeeStructure): FeeCalculationResult => {
+export const calculateBridgeFees = (srcAmount: Hex, feeStructure: FeeStructure): BridgeFees => {
   const { feeFixed, feeRateBasisPoints } = feeStructure
 
   // Format source input
@@ -32,8 +28,6 @@ export const calculateBridgeFees = (srcAmount: Hex, feeStructure: FeeStructure):
   const destAmount = toHex(destAmountBigInt)
 
   return {
-    destAmount,
-    feeFixed,
-    feeVariable,
+    feeFixed, feeVariable, srcAmount,
   }
 }

package/src/util/createBridgeTransfer.ts

@@ -0,0 +1,31 @@
+import type { Address, Hex } from '@xylabs/sdk-js'
+import { hexToBigInt } from '@xylabs/sdk-js'
+import type { Transfer } from '@xyo-network/xl1-sdk'
+import { createTransferPayload } from '@xyo-network/xl1-sdk'
+
+import type { BridgeFees } from './BridgeFees.ts'
+
+/**
+ * Calculates the transfer representing the bridging of funds including the appropriate amounts for the bridge fees
+ * @param sender The client attempting to bridge
+ * @param srcAmount The amount the client is attempting to bridge
+ * @param escrowAddress The address in which bridged funds will be held until the transfer is executed on the destination chain
+ * @param feesAddress The address to which bridge fees will be paid
+ * @param context An object containing the necessary fee and amount information to construct the transfer context
+ * @returns A transfer representing the bridging of funds including the appropriate amounts for the bridge fees
+ */
+export const createBridgeTransfer = (sender: Address, srcAmount: Hex, escrowAddress: Address, feesAddress: Address, context: BridgeFees): Transfer => {
+  const { feeFixed, feeVariable } = context
+  const escrowAmount = hexToBigInt(srcAmount)
+  const feesAmount = hexToBigInt(feeFixed) + hexToBigInt(feeVariable)
+  const transfers: Record<Address, bigint>
+  // If the escrow and fee addresses are the same
+    = escrowAddress === feesAddress
+    // combine the amounts into a single transfer to that address
+      ? { [feesAddress]: escrowAmount + feesAmount }
+    // otherwise, create separate transfers to the escrow and fees addresses
+      : { [escrowAddress]: escrowAmount, [feesAddress]: feesAmount }
+  const transfer = createTransferPayload(sender, transfers, context)
+
+  return transfer
+}

package/src/util/generateBridgeEstimate.ts

@@ -1,21 +1,22 @@
 import type { Hex } from '@xylabs/sdk-js'
-import { hexToBigInt, toAddress } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { toAddress } from '@xylabs/sdk-js'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import { PayloadBuilder } from '@xyo-network/sdk-js'
 import type {
-  BridgeIntent, BridgeIntentFields, Config,
-  Transfer,
+  BridgeIntent, BridgeIntentFields, Transfer,
 } from '@xyo-network/xl1-sdk'
-import { BridgeIntentSchema, createTransferPayload } from '@xyo-network/xl1-sdk'
+import { BridgeIntentSchema } from '@xyo-network/xl1-sdk'
 import { v4 } from 'uuid'
 
 import { getBridgeSettings } from '../config/index.ts'
 import { calculateBridgeFees } from './calculateBridgeFees.ts'
+import { createBridgeTransfer } from './createBridgeTransfer.ts'
 
 export const generateBridgeEstimate = async (
   srcAddress: Hex,
   srcAmount: Hex,
   destAddress: Hex,
-  config: Config,
+  config: BridgeConfig,
   nonceOverride?: string,
 ): Promise<[BridgeIntent, Transfer]> => {
   const {
@@ -26,9 +27,6 @@ export const generateBridgeEstimate = async (
 
   // Calculate fees and destination amount
   const fees = calculateBridgeFees(srcAmount, { feeFixed, feeRateBasisPoints })
-  const {
-    destAmount, feeFixed: feeFixedAmount, feeVariable,
-  } = fees
 
   // Generate a unique nonce for the bridge intent
   const nonce = nonceOverride ?? v4()
@@ -44,20 +42,14 @@ export const generateBridgeEstimate = async (
     // Destination
     dest: remoteChainId,
     destAddress,
-    destAmount,
+    destAmount: srcAmount, // This is a 1:1 bridge. Fees are handled at the transfer level, not the bridge intent level.
     destToken: remoteTokenAddress,
     nonce,
   }
   const bridgeIntent: BridgeIntent = new PayloadBuilder<BridgeIntent>({ schema: BridgeIntentSchema }).fields(bridgeIntentFields).build()
 
   // Build the transfer
-  const context = {
-    destAmount, feeFixed: feeFixedAmount, feeVariable,
-  }
-  const transfer: Transfer = createTransferPayload(sender, {
-    [escrowAddress]: hexToBigInt(destAmount),
-    [feesAddress]: hexToBigInt(feeFixedAmount) + hexToBigInt(feeVariable),
-  }, context)
+  const transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees)
 
   return [bridgeIntent, transfer]
 }