@xyo-network/chain-bridge 1.20.15 → 1.20.17

package/src/services/getServices.ts

@@ -1,41 +0,0 @@
-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 { HDWallet } from '@xyo-network/sdk-js'
-import { BridgeableToken__factory, LiquidityPoolBridge__factory } from '@xyo-network/typechain'
-import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-import { getAddress, Wallet } from 'ethers'
-
-import type { EthTxState } from './EthTxState.ts'
-import { getIterableMap } from './getIterableMap.ts'
-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: 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(context)
-  const {
-    remoteBridgeContractAddress, remoteChainWalletPrivateKey, remoteTokenAddress, mnemonic,
-  } = 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)
-  const bridge = LiquidityPoolBridge__factory.connect(getAddress(remoteBridgeContractAddress), wallet)
-  // const approvalAmount = 18n * 10n ** 9n * 10n ** 18n // 18 billion tokens with 18 decimals
-  // const contractApprovalTx = await bridgeableToken.connect(wallet).approve(bridge.getAddress(), approvalAmount)
-  // await contractApprovalTx.wait(1)
-  // Assert we are contract owner so we can call ownable methods
-  const bridgeOwner = await bridge.owner()
-  assertEx(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => 'Wallet is not the owner of the bridge contract')
-  return {
-    account, bridge, bridgeableToken, ethTxStateMap, gateway, provider, wallet, xl1TxStateMap,
-  }
-}

package/src/services/index.ts

@@ -1,5 +0,0 @@
-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

@@ -1,16 +0,0 @@
-import {
-  type Hex, HexZod, type JsonObject,
-} from '@xylabs/sdk-js'
-import { z } from 'zod'
-
-export interface BridgeFees extends JsonObject {
-  feeFixed: Hex
-  feeVariable: Hex
-  srcAmount: Hex
-}
-
-export const BridgeFeesZod = z.object({
-  feeFixed: HexZod,
-  feeVariable: HexZod,
-  srcAmount: HexZod,
-})

package/src/util/bridgeFeesAsBigInt.ts

@@ -1,15 +0,0 @@
-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,33 +0,0 @@
-import type { Hex } from '@xylabs/sdk-js'
-import { hexToBigInt, toHex } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-
-import type { BridgeFees } from './BridgeFees.ts'
-
-export type FeeStructure = Pick<BridgeConfig, 'feeFixed' | 'feeRateBasisPoints'>
-
-export const calculateBridgeFees = (srcAmount: Hex, feeStructure: FeeStructure): BridgeFees => {
-  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 {
-    feeFixed, feeVariable, srcAmount,
-  }
-}

package/src/util/calculateMaxBridgeAmount.ts

@@ -1,22 +0,0 @@
-import type { Hex } from '@xylabs/sdk-js'
-import { hexToBigInt, toHex } from '@xylabs/sdk-js'
-
-import type { FeeStructure } from './calculateBridgeFees.ts'
-
-/**
- * Given a user's total available balance, calculates the maximum amount they can bridge
- * after accounting for the fixed and variable bridge fees.
- *
- * Solving for M where: M + feeFixed + (M * basisPoints / 10_000) = balance
- * => M = (balance - feeFixed) * 10_000 / (10_000 + basisPoints)
- */
-export const calculateMaxBridgeAmount = (balance: Hex, feeStructure: FeeStructure): Hex => {
-  const { feeFixed, feeRateBasisPoints } = feeStructure
-  const balanceBigInt = hexToBigInt(balance)
-  const feeFixedBigInt = hexToBigInt(feeFixed)
-
-  if (balanceBigInt <= feeFixedBigInt) return toHex(0n)
-
-  const maxAmount = ((balanceBigInt - feeFixedBigInt) * 10_000n) / (10_000n + BigInt(feeRateBasisPoints))
-  return toHex(maxAmount)
-}

package/src/util/createBridgeTransfer.ts

@@ -1,31 +0,0 @@
-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,55 +0,0 @@
-import type { Hex } from '@xylabs/sdk-js'
-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, Transfer,
-} 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: BridgeConfig,
-  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 })
-
-  // 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: 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 transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees)
-
-  return [bridgeIntent, transfer]
-}

package/src/util/getConfigFromEnv.ts

@@ -1,15 +0,0 @@
-import { type Config, ConfigZod } from '@xyo-network/xl1-sdk'
-import type { Configuration } from 'yargs-parser'
-import parser from 'yargs-parser'
-
-export const ConfigParserEnvPrefix = 'XL1_'
-export const ConfigParserConfiguration: Partial<Configuration> = {
-  'dot-notation': true, // foo.bar → { foo: { bar } }
-  'parse-numbers': false, // Don't auto-parse numbers to allow strings like "0x1"
-  'populate--': true, // Populate -- with all options so we can detected user-supplied vs defaults
-}
-
-export const getConfigFromEnv = (): Config => {
-  const parsed = parser([], { configuration: ConfigParserConfiguration, envPrefix: ConfigParserEnvPrefix })
-  return ConfigZod.parse(parsed)
-}

package/src/util/index.ts

@@ -1,7 +0,0 @@
-export * from './BridgeFees.ts'
-export * from './bridgeFeesAsBigInt.ts'
-export * from './calculateBridgeFees.ts'
-export * from './calculateMaxBridgeAmount.ts'
-export * from './createBridgeTransfer.ts'
-export * from './generateBridgeEstimate.ts'
-export * from './getConfigFromEnv.ts'

package/src/validation/AsyncLogger.ts

@@ -1,5 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-
-export interface AsyncLogger {
-  log: (message: string) => Promisable<unknown>
-}

package/src/validation/index.ts

@@ -1,6 +0,0 @@
-export * from './validateBridgeEstimateExact.ts'
-export * from './validateBridgeTransaction.ts'
-export * from './validateSufficientLiquiditySourceAllowance.ts'
-export * from './validateSufficientLiquiditySourceBalance.ts'
-export * from './validateSufficientRunnerEthBalanceForGas.ts'
-export * from './validateSufficientXL1SourceAddressBalance.ts'

package/src/validation/validateBridgeEstimate.ts

@@ -1,60 +0,0 @@
-import { hexToBigInt, isUndefined } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import type { BridgeIntent, Transfer } from '@xyo-network/xl1-sdk'
-
-import { getBridgeSettings } from '../config/index.ts'
-import { calculateBridgeFees } from '../util/index.ts'
-
-/**
- * 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: BridgeConfig,
-): 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.srcAmount)) {
-    return false
-  }
-
-  return true
-}

package/src/validation/validateBridgeEstimateExact.ts

@@ -1,39 +0,0 @@
-import { hexToBigInt, isUndefined } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { BridgeIntent, Transfer } from '@xyo-network/xl1-sdk'
-
-import { getMaxBridgeAmount } from '../config/index.ts'
-import { generateBridgeEstimate } from '../util/index.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: BridgeConfig,
-): Promise<boolean> => {
-  const {
-    srcAddress, srcAmount, destAddress,
-  } = intent
-
-  // Reject if the requested amount exceeds the configured maximum
-  if (hexToBigInt(srcAmount) > hexToBigInt(getMaxBridgeAmount(config))) return false
-
-  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/validation/validateBridgeTransaction.ts

@@ -1,53 +0,0 @@
-import { asAddress } from '@xylabs/sdk-js'
-import {
-  addressesContains, BoundWitnessValidator, payloadHashesContainsAll, payloadSchemasContainsAll,
-} from '@xyo-network/boundwitness-validator'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  BridgeIntent, TransactionBoundWitness, Transfer,
-} from '@xyo-network/xl1-sdk'
-import { BridgeIntentSchema, TransferSchema } from '@xyo-network/xl1-sdk'
-
-import { getXl1ChainId } from '../config/index.ts'
-
-/**
- * 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: BridgeConfig,
-): Promise<boolean> => {
-  const { srcAddress } = intent
-
-  // Ensure the transaction is for the correct source chain
-  const chainId = getXl1ChainId(config)
-  if (signedTxBw.chain !== chainId) return false
-
-  // Ensure only the expected number of payloads exist (do not allow ambiguous extras)
-  if (signedTxBw.payload_hashes.length != 2) return false
-  // Ensure the payloads match the expected schemas
-  if (!payloadSchemasContainsAll(signedTxBw, [BridgeIntentSchema, TransferSchema])) return false
-  // Ensure the hashes match the intent and transfer
-  const hashes = await PayloadBuilder.hashes([intent, transfer])
-  if (!payloadHashesContainsAll(signedTxBw, hashes)) return false
-  // Ensure the BoundWitness is valid and signed by the sender
-  const errors = await new BoundWitnessValidator(signedTxBw).validate()
-  if (errors.length > 0) return false
-
-  // Ensure the sender's address is included in the addresses
-  const sender = asAddress(srcAddress, true)
-  if (!addressesContains(signedTxBw, sender)) return false
-
-  return true
-}

package/src/validation/validateSufficientLiquiditySourceAllowance.ts

@@ -1,39 +0,0 @@
-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'
-
-import type { AsyncLogger } from './AsyncLogger.ts'
-
-/**
- * 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 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
- * @returns True if the liquidity source allowance is sufficient to execute the bridge
- */
-export const validateSufficientLiquiditySourceAllowance = async (
-  tx: SignedHydratedTransaction,
-  offChainPayloads: Payload[],
-  bridgeableToken: BridgeableToken,
-  bridge: LiquidityPoolBridge,
-  logger?: AsyncLogger,
-) => {
-  // Get the amount being bridged from the bridge intent
-  const allPayloads = [...tx[1], ...offChainPayloads]
-  const bridgeIntent = assertEx(allPayloads.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/validation/validateSufficientLiquiditySourceBalance.ts

@@ -1,38 +0,0 @@
-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'
-
-import type { AsyncLogger } from './AsyncLogger.ts'
-
-/**
- * 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 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
- * @returns True if the liquidity source balance is sufficient to execute the bridge
- */
-export const validateSufficientLiquiditySourceBalance = async (
-  tx: SignedHydratedTransaction,
-  offChainPayloads: Payload[],
-  bridgeableToken: BridgeableToken,
-  bridge: LiquidityPoolBridge,
-  logger?: AsyncLogger,
-) => {
-  // Get the amount being bridged from the bridge intent
-  const allPayloads = [...tx[1], ...offChainPayloads]
-  const bridgeIntent = assertEx(allPayloads.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/validation/validateSufficientRunnerEthBalanceForGas.ts

@@ -1,57 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { ContractTransaction, Wallet } from 'ethers'
-
-import type { AsyncLogger } from './AsyncLogger.ts'
-
-const DEFAULT_GAS_BUFFER_BPS = 2000n // 20%
-
-/**
- * Validates that the wallet (the account that will submit the tx) has enough ETH
- * to cover the estimated gas cost (plus a buffer) for the transaction.
- * @param preparedTx The transaction that is being prepared for submission.
- * This should be a fully populated transaction (to/from/data/value) except for gas fields.
- * @param wallet The wallet that will be used to submit the transaction.
- * @param logger Optional logger for asynchronous logging.
- * @param bufferBps The buffer to apply to the estimated gas cost, in basis points (1/100th of a percent).
- * @returns A boolean indicating whether the wallet has sufficient ETH to cover the estimated gas cost with the buffer applied.
- */
-export const validateSufficientRunnerEthBalanceForGas = async (
-  preparedTx: ContractTransaction,
-  wallet: Wallet,
-  logger?: AsyncLogger,
-  bufferBps: bigint = DEFAULT_GAS_BUFFER_BPS,
-) => {
-  const provider = assertEx(wallet.provider, () => 'Wallet provider is not defined')
-
-  // Fee data (EIP-1559 preferred, gasPrice fallback)
-  const feeData = await provider.getFeeData()
-  const perGas = feeData.maxFeePerGas ?? feeData.gasPrice
-  if (perGas == null) {
-    await logger?.log('[gas] unable to resolve gas price / maxFeePerGas from provider')
-    return true // don’t hard-fail; provider may not support fee data
-  }
-
-  // Estimate gas
-  const transactionRequest = {
-    ...preparedTx,
-    from: await wallet.getAddress(),
-  }
-  const estGas = await provider.estimateGas(transactionRequest)
-
-  // Include any value sent with the tx
-  const txValue = preparedTx?.value ?? 0n
-
-  // Required = (gas * perGas + value) * (1 + buffer)
-  const baseRequired = estGas * perGas + txValue
-  const required = (baseRequired * (10_000n + bufferBps)) / 10_000n
-
-  const balance = await provider.getBalance(await wallet.getAddress())
-
-  await logger?.log(
-    `[gas] runner=${await wallet.getAddress()} balance=${balance.toString()} `
-    + `estGas=${estGas.toString()} perGas=${perGas.toString()} value=${txValue.toString()} `
-    + `requiredWithBuffer=${required.toString()} bufferBps=${bufferBps.toString()}`,
-  )
-
-  return balance >= required
-}

package/src/validation/validateSufficientXL1SourceAddressBalance.ts

@@ -1,39 +0,0 @@
-import {
-  asAddress, assertEx, hexToBigInt,
-} from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/chain-orchestration'
-import type { BridgeIntent, XyoGatewayRunner } from '@xyo-network/xl1-sdk'
-
-import { generateBridgeEstimate } from '../util/index.ts'
-import type { AsyncLogger } from './AsyncLogger.ts'
-
-/**
- * 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 bridgeIntent The bridge intent containing the details of the bridge transaction, including the source address and amount being bridged
- * @param gateway The XyoGatewayRunner to check the balance of the source address on XL1
- * @param config The bridge configuration, used to generate a bridge estimate for the transaction
- * @param logger Optional logger for asynchronous logging
- * @returns True if the liquidity source balance is sufficient to execute the bridge
- */
-export const validateSufficientXL1SourceAddressBalance = async (
-  bridgeIntent: BridgeIntent,
-  gateway: XyoGatewayRunner,
-  config: BridgeConfig,
-  logger?: AsyncLogger,
-) => {
-  // Get the amount being bridged from the bridge intent
-  const viewer = assertEx(gateway.connection.viewer, () => 'Gateway connection does not have a viewer')
-  const {
-    srcAddress, srcAmount, destAddress,
-  } = bridgeIntent
-  const srcAddressBranded = asAddress(srcAddress, () => `Invalid source address in bridge intent: ${srcAddress}`)
-  const [_, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config)
-  const totalAmount = Object.values(calculatedTransfer.transfers).reduce((acc, transfer) => acc + hexToBigInt(transfer), 0n)
-
-  // Check the srcAddress balance on XL1 for the bridge
-  const accountBalance = await viewer.account.balance.accountBalance(srcAddressBranded)
-  await logger?.log(`Account balance for ${srcAddressBranded}: ${accountBalance.toString()}`)
-  return accountBalance >= totalAmount
-}