@xyo-network/chain-bridge 1.17.2 → 1.17.6

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

@@ -1,83 +1,56 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
-import {
-  hexToBigInt, toAddress, toHex,
-} from '@xylabs/sdk-js'
-import { createTransferPayload } from '@xyo-network/chain-protocol'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { assertEx, toAddress } from '@xylabs/sdk-js'
 import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
-import type {
-  BridgeIntent, BridgeIntentFields, ChainId, Transfer,
-} from '@xyo-network/xl1-protocol'
 import {
-  BridgeIntentFieldsZod, BridgeIntentSchema, TransferSchema,
+  BridgeIntentFieldsZod, BridgeIntentSchema, toXL1BlockNumber, TransactionBoundWitnessZod, TransferSchema,
 } from '@xyo-network/xl1-protocol'
-import { v4 } from 'uuid'
+import { buildUnsignedTransaction, type Config } from '@xyo-network/xl1-protocol-sdk'
 import { z } from 'zod'
 
-import { ChainIdPathParam } from '../pathParams/index.ts'
-
-// TODO: Get from config
-const TOKEN_ADDRESS = '0x5FbDB2315678afecb367f032d93F642f64180aa3'
-const bridgeableTokenContract = toHex(TOKEN_ADDRESS)
-const xl1ChainId: ChainId = toAddress('0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9')
-const fixedFee: bigint = 1_000_000_000_000_000n
-const percentFee: bigint = 5n // 0.5%
-const bridgeEscrowAddress = toAddress('0x0a')
-const bridgeFeesAddress = toAddress('0x0b')
-const remoteChainId: ChainId = toHex('0x01')
-
-const params = z.object({ chainId: ChainIdPathParam })
-const body = BridgeIntentFieldsZod.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true,
-})
-const response = z.tuple([
-  PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-  PayloadZodLooseOfSchema(TransferSchema),
-])
-const validateRequest = requestHandlerValidator({
-  params, body, response,
-})
-
-export const bridgeToRemoteEstimate: RouteDefinition = {
-  method: 'post',
-  path: '/bridge/chains/:chainId/bridgeToRemote/estimate',
-  handlers: validateRequest((req, res) => {
-    const {
-      srcAddress, srcAmount, destAddress,
-    } = req.body
-
-    const srcAmountBigInt = hexToBigInt(srcAmount)
-    const feeAmount = fixedFee + ((srcAmountBigInt * percentFee) / 100n)
-    const destAmountBigInt = srcAmountBigInt > feeAmount ? srcAmountBigInt - feeAmount : 0n
-    const destAmount = toHex(destAmountBigInt)
-    const nonce = v4()
-
-    const sender = toAddress(srcAddress)
-
-    const bridgeIntentFields: BridgeIntentFields = {
-      // Source
-      src: xl1ChainId,
-      srcAddress,
-      srcAmount,
-      srcToken: xl1ChainId,
-
-      // Destination
-      dest: remoteChainId,
-      destAddress,
-      destAmount,
-      destToken: bridgeableTokenContract,
-      nonce,
-    }
-    const bridgeIntent: BridgeIntent = new PayloadBuilder<BridgeIntent>({ schema: BridgeIntentSchema }).fields(bridgeIntentFields).build()
-
-    const transfer: Transfer = createTransferPayload(sender, {
-      [bridgeEscrowAddress]: destAmountBigInt,
-      [bridgeFeesAddress]: feeAmount,
-    })
-
-    res.json([bridgeIntent, transfer])
-  }),
+import { getGateway, getXl1ChainId } from '../../../../../config/index.ts'
+import { generateBridgeEstimate } from '../../../../../util/index.ts'
+import { getRemoteChainIdZod } from '../pathParams/index.ts'
+
+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,
+  })
+
+  return {
+    method: 'post',
+    path: '/bridge/chains/:chainId/bridgeToRemote/estimate',
+    handlers: validateRequest(async (req, res) => {
+      const xl1ChainId = getXl1ChainId(config)
+      const {
+        srcAddress, srcAmount, destAddress,
+      } = req.body
+      const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config)
+      const sender = toAddress(srcAddress)
+
+      // Use viewer to get current block
+      const gateway = await getGateway(config)
+      const viewer = assertEx(gateway.connectionInstance.viewer, () => new Error('Viewer not available on gateway connection'))
+      const currentBlockNumber = await viewer.currentBlockNumber()
+      // Calculate nbf/exp
+      const nbf = toXL1BlockNumber(currentBlockNumber, true)
+      const exp = toXL1BlockNumber(currentBlockNumber + 1000, true)
+      // Build unsigned transaction representing the transfer that will be signed by srcAddress
+      const [txBw] = await buildUnsignedTransaction(xl1ChainId, [transfer], [bridgeIntent], nbf, exp, sender)
+
+      // Return the TX to the caller for signing
+      res.json([txBw, bridgeIntent, transfer])
+    }),
+  }
 }

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

@@ -1,55 +1,103 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
-import { toAddress, toHex } from '@xylabs/sdk-js'
+import {
+  asAddress, asHex, toHex,
+} from '@xylabs/sdk-js'
 import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
-import type { BridgeDestinationObservation } from '@xyo-network/xl1-protocol'
+import type { BridgeDestinationObservation, BridgeSourceObservation } from '@xyo-network/xl1-protocol'
 import {
-  BridgeDestinationObservationFieldsZod,
-  BridgeDestinationObservationSchema,
+  BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema, BridgeIntentFieldsZod, BridgeIntentSchema, BridgeSourceObservationFieldsZod,
+  BridgeSourceObservationSchema,
 } from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
 import { z } from 'zod'
 
-import { ChainIdPathParam } from '../pathParams/index.ts'
-
-const params = z.object({
-  chainId: ChainIdPathParam,
-  nonce: z.string(),
-})
-const response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(
-  BridgeDestinationObservationFieldsZod.shape,
-)
-
-const validateRequest = requestHandlerValidator({
-  params,
-  response,
-})
-
-export const bridgeToRemoteStatus: RouteDefinition = {
-  method: 'get',
-  path: '/bridge/chains/:chainId/bridgeToRemote/status/:nonce',
-  handlers: validateRequest(async (req, res) => {
-    const { chainId } = req.params
-    const rand = await Promise.resolve(Math.random())
-
-    // TODO: Replace with actual lookup logic (e.g. database or chain query)
-    const found = rand > 0.5 // simulate lookup
-    if (!found) return res.sendStatus(404)
-
-    const confirmed = rand > 0.8 // simulate pending/confirmed
-    if (!confirmed) return res.sendStatus(204)
-
-    const observation: BridgeDestinationObservation = {
-      schema: BridgeDestinationObservationSchema,
-      dest: chainId,
-      destAddress: toAddress('0xabc'),
-      destAmount: toHex('0x100'),
-      destToken: toAddress('0xdef'),
-      src: toAddress('0x02'),
-      srcAddress: toAddress('0x123'),
-      srcAmount: toHex('0x200'),
-      srcToken: toHex('0x456'),
-      destConfirmation: toHex('0x9999'),
-    }
-    res.json(observation)
-  }),
+import { getBridgeSettings } from '../../../../../config/index.ts'
+import { generateBridgeEstimate } from '../../../../../util/index.ts'
+import { getRemoteChainIdZod } from '../pathParams/index.ts'
+
+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,
+  })
+
+  return {
+    method: 'get',
+    path: '/bridge/chains/:chainId/bridgeToRemote/status/:nonce',
+    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 {
+        remoteTokenAddress, xl1ChainId, xl1TokenAddress,
+      } = await getBridgeSettings(config)
+
+      const src = xl1ChainId
+      const srcAddress = asAddress('2222222222222222222222222222222222222222', true)
+      const srcAmount = asHex('0x200', true)
+      const srcToken = xl1TokenAddress
+
+      const dest = chainId
+      const destAddress = asAddress('3333333333333333333333333333333333333333', true)
+      const destAmount = asHex('0x100', true)
+      const destToken = remoteTokenAddress
+
+      if (mockStatus === 0) return res.sendStatus(404)
+      if (mockStatus > 0) {
+        const [observation] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config, req.params.nonce)
+        result[0] = observation
+      }
+      if (mockStatus > 1) {
+        const observation: BridgeSourceObservation = {
+          schema: BridgeSourceObservationSchema,
+          dest,
+          destAddress,
+          destAmount,
+          destToken,
+          src,
+          srcAddress,
+          srcAmount,
+          srcToken,
+        }
+        result[1] = observation
+      }
+      if (mockStatus > 2) {
+        const observation: BridgeDestinationObservation = {
+          schema: BridgeDestinationObservationSchema,
+          dest,
+          destAddress,
+          destAmount,
+          destToken,
+          src,
+          srcAddress,
+          srcAmount,
+          srcToken,
+          destConfirmation: toHex('0x9999'),
+        }
+        result[2] = observation
+      }
+
+      res.json(result)
+    }),
+  }
 }

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

@@ -1,3 +1,4 @@
+export * from './bridgeConfig.ts'
 export * from './bridgeFromRemoteStatus.ts'
 export * from './bridgeToRemote.ts'
 export * from './bridgeToRemoteEstimate.ts'

package/src/server/routes/index.ts

@@ -1,3 +1 @@
-export * from './address/index.ts'
 export * from './addRoutes.ts'
-export * from './healthz/index.ts'

package/src/server/server.ts

@@ -1,33 +1,39 @@
-import type { Logger } from '@xylabs/sdk-js'
+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 } from '@xyo-network/xl1-protocol-sdk'
 
+import { getNode } from '../manifest/index.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.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')
-// }
+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.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
@@ -36,16 +42,16 @@ interface GetServerContext {
 }
 
 export const getServer = async (context: GetServerContext) => {
-  const { logger } = context
-  const { port } = context.config.bridge
-  await Promise.resolve() // bios booting is currently disabled
-  // 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 app = getApp()
+  const { logger, config } = context
+  const { port, mnemonic } = config.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)
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`))
   server.setTimeout(20_000)
   return server

package/src/util/calculateBridgeFees.ts

@@ -0,0 +1,39 @@
+import type { Hex } from '@xylabs/sdk-js'
+import { hexToBigInt, toHex } from '@xylabs/sdk-js'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+
+export type FeeStructure = Pick<Config['bridge'], 'feeFixed' | 'feeRateBasisPoints'>
+
+export interface FeeCalculationResult {
+  destAmount: Hex
+  feeFixed: Hex
+  feeVariable: Hex
+}
+
+export const calculateBridgeFees = (srcAmount: Hex, feeStructure: FeeStructure): FeeCalculationResult => {
+  const { feeFixed, feeRateBasisPoints } = feeStructure
+
+  // Format source input
+  const srcAmountBigInt = hexToBigInt(srcAmount)
+
+  // Calculate fixed fee
+  const feeFixedBigInt = hexToBigInt(feeFixed)
+
+  // Integer-safe basis point calculation (floor division)
+  const feeVariableBigInt
+    = (srcAmountBigInt * BigInt(feeRateBasisPoints)) / 10_000n
+  const feeVariable = toHex(feeVariableBigInt)
+
+  // Calculate total fee
+  const feeTotalBigInt = feeFixedBigInt + feeVariableBigInt
+
+  // Calculate destination amount
+  const destAmountBigInt = srcAmountBigInt > feeTotalBigInt ? srcAmountBigInt - feeTotalBigInt : 0n
+  const destAmount = toHex(destAmountBigInt)
+
+  return {
+    destAmount,
+    feeFixed,
+    feeVariable,
+  }
+}

package/src/util/generateBridgeEstimate.ts

@@ -0,0 +1,64 @@
+import type { Hex } from '@xylabs/sdk-js'
+import { hexToBigInt, toAddress } from '@xylabs/sdk-js'
+import { createTransferPayload } from '@xyo-network/chain-protocol'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type {
+  BridgeIntent, BridgeIntentFields, Transfer,
+} from '@xyo-network/xl1-protocol'
+import { BridgeIntentSchema } from '@xyo-network/xl1-protocol'
+import { type Config } from '@xyo-network/xl1-protocol-sdk'
+import { v4 } from 'uuid'
+
+import { getBridgeSettings } from '../config/index.ts'
+import { calculateBridgeFees } from './calculateBridgeFees.ts'
+
+export const generateBridgeEstimate = async (
+  srcAddress: Hex,
+  srcAmount: Hex,
+  destAddress: Hex,
+  config: Config,
+  nonceOverride?: string,
+): Promise<[BridgeIntent, Transfer]> => {
+  const {
+    escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress,
+  } = await getBridgeSettings(config)
+
+  const sender = toAddress(srcAddress)
+
+  // 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()
+
+  // Build the bridge intent
+  const bridgeIntentFields: BridgeIntentFields = {
+    // Source
+    src: xl1ChainId,
+    srcAddress: sender,
+    srcAmount,
+    srcToken: xl1TokenAddress,
+
+    // Destination
+    dest: remoteChainId,
+    destAddress,
+    destAmount,
+    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)
+
+  return [bridgeIntent, transfer]
+}

package/src/util/index.ts

@@ -0,0 +1,5 @@
+export * from './calculateBridgeFees.ts'
+export * from './generateBridgeEstimate.ts'
+export * from './validateBridgeEstimate.ts'
+export * from './validateBridgeEstimateExact.ts'
+export * from './validateBridgeTransaction.ts'

package/src/util/validateBridgeEstimate.ts

@@ -0,0 +1,60 @@
+import { hexToBigInt, isUndefined } from '@xylabs/sdk-js'
+import type { BridgeIntent, Transfer } from '@xyo-network/xl1-protocol'
+import { type Config } from '@xyo-network/xl1-protocol-sdk'
+
+import { getBridgeSettings } from '../config/index.ts'
+import { calculateBridgeFees } from './calculateBridgeFees.js'
+
+/**
+ * Validates a bridge estimate by checking the intent and transfer against the provided configuration. This method
+ * exists to allow for "at least" validation of a bridge estimates in case we want to allow for some flexibility in
+ * the bridge estimate.
+ * @param intent The BridgeIntent
+ * @param transfer The Transfer
+ * @param config The Config
+ * @returns True if the bridge estimate satisfies bridging conditions, false otherwise.
+ */
+export const validateBridgeEstimate = async (
+  intent: BridgeIntent,
+  transfer: Transfer,
+  config: Config,
+): Promise<boolean> => {
+  const {
+    escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress,
+  } = await getBridgeSettings(config)
+
+  // 1. Basic chain + token checks
+  if (intent.src !== xl1ChainId) return false
+  if (intent.dest !== remoteChainId) return false
+  if (intent.srcToken !== xl1TokenAddress) return false
+  if (intent.destToken !== remoteTokenAddress) return false
+
+  // 2. Validate transfer outputs: escrow receives destAmount,
+  //    feesAddress receives feeFixed + variableFee.
+  const outputs = transfer?.transfers ?? {}
+  const escrowOut = outputs[escrowAddress]
+  const feeOut = outputs[feesAddress]
+  if (isUndefined(escrowOut) || isUndefined(feeOut)) return false
+
+  // Convert hex amounts
+  const destAmount = hexToBigInt(intent.destAmount)
+  const escrowAmount = hexToBigInt(escrowOut)
+
+  if (escrowAmount !== destAmount) return false
+
+  // 3. Recalculate fees and compare
+  const fees = calculateBridgeFees(intent.srcAmount, { feeFixed, feeRateBasisPoints })
+
+  const expectedFeeTotal
+    = hexToBigInt(fees.feeFixed) + hexToBigInt(fees.feeVariable)
+
+  const feeAmount = hexToBigInt(feeOut)
+  if (feeAmount < expectedFeeTotal) return false
+
+  // 4. Check derived dest amount
+  if (hexToBigInt(intent.destAmount) !== hexToBigInt(fees.destAmount)) {
+    return false
+  }
+
+  return true
+}

package/src/util/validateBridgeEstimateExact.ts

@@ -0,0 +1,34 @@
+import { isUndefined } from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { BridgeIntent, Transfer } from '@xyo-network/xl1-protocol'
+import { type Config } from '@xyo-network/xl1-protocol-sdk'
+
+import { generateBridgeEstimate } from './generateBridgeEstimate.ts'
+
+/**
+ * Validates a bridge estimate by checking the intent and transfer against the provided configuration. This method
+ * only returns true if the bridge estimate matches exactly.
+ * @param intent The BridgeIntent
+ * @param transfer The Transfer
+ * @param config The Config
+ * @returns True if the bridge estimate satisfies bridging conditions, false otherwise.
+ */
+export const validateBridgeEstimateExact = async (
+  intent: BridgeIntent,
+  transfer: Transfer,
+  config: Config,
+): Promise<boolean> => {
+  const {
+    srcAddress, srcAmount, destAddress,
+  } = intent
+  const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config)
+  if (isUndefined(calculatedIntent) || isUndefined(calculatedTransfer)) return false
+  const { nonce: expectedIntentNonce, ...expectedIntentStatic } = calculatedIntent
+  const { nonce: actualIntentNonce, ...actualIntentStatic } = intent
+  if (await PayloadBuilder.dataHash(expectedIntentStatic) !== await PayloadBuilder.dataHash(actualIntentStatic)) return false
+  const { epoch: expectedTransferEpoch, ...expectedTransferStatic } = calculatedTransfer
+  const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer
+  if (await PayloadBuilder.dataHash(expectedTransferStatic) !== await PayloadBuilder.dataHash(actualTransferStatic)) return false
+
+  return true
+}

package/src/util/validateBridgeTransaction.ts

@@ -0,0 +1,40 @@
+import { asAddress, isDefined } from '@xylabs/sdk-js'
+import {
+  addressesContains, BoundWitnessValidator, payloadHashesContainsAll,
+} from '@xyo-network/boundwitness-validator'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type {
+  BridgeIntent, TransactionBoundWitness, Transfer,
+} from '@xyo-network/xl1-protocol'
+import { type Config } from '@xyo-network/xl1-protocol-sdk'
+
+/**
+ * Validates a bridge estimate by checking the intent and transfer against the provided configuration. This method
+ * exists to allow for "at least" validation of a bridge estimates in case we want to allow for some flexibility in
+ * the bridge estimate.
+ * @ param signedTransaction The signed transaction bound witness
+ * @param signedTxBw The signed transaction bound witness
+ * @param intent The BridgeIntent
+ * @param transfer The Transfer
+ * @param config The Config
+ * @returns True if the bridge estimate satisfies bridging conditions, false otherwise.
+ */
+export const validateBridgeTransaction = async (
+  signedTxBw: TransactionBoundWitness,
+  intent: BridgeIntent,
+  transfer: Transfer,
+  config: Config,
+): Promise<boolean> => {
+  const { srcAddress } = intent
+
+  const errors = await new BoundWitnessValidator(signedTxBw).validate()
+  if (isDefined(errors) && errors.length > 0) return false
+
+  const sender = asAddress(srcAddress, true)
+  if (!addressesContains(signedTxBw, sender)) return false
+
+  const hashes = await PayloadBuilder.hashes([intent, transfer])
+  if (!payloadHashesContainsAll(signedTxBw, hashes)) return false
+
+  return true
+}