@gibs/bridge-sdk 1.9.1 → 1.12.0

package/src/settings.ts

@@ -1,13 +1,21 @@
-import { concatHex, encodeAbiParameters, encodeFunctionData, getAddress, type Hex, isAddress, zeroAddress } from "viem";
-import { Chains, isNative, nativeAssetOut, type Pathway, pathway } from "./config.js";
-import { FeeType } from "./fee-type.js";
-import type { BridgeKey, Token } from "./types.js";
-import type { TokenBridgeInfo } from "./chain-info.js";
-import * as abis from "./abis.js";
+import {
+  concatHex,
+  encodeAbiParameters,
+  encodeFunctionData,
+  getAddress,
+  type Hex,
+  isAddress,
+  zeroAddress,
+} from 'viem';
+import * as abis from './abis.js';
+import type { TokenBridgeInfo } from './chain-info.js';
+import { type Chains, isNative, nativeAssetOut, type Pathway, pathway } from './config.js';
+import { FeeType } from './fee-type.js';
+import type { BridgeKey, Token } from './types.js';
 
-export const oneEther = 10n ** 18n
+export const oneEther = 10n ** 18n;
 
-export const basisPoints = 10_000n
+export const basisPoints = 10_000n;
 
 /**
  * Returns the bridge pathway (configuration) for a given bridge key, asset in, and whether to use the production pathway
@@ -21,12 +29,10 @@ export const bridgePathway = ({
   isProd,
   assetIn,
 }: {
-  bridgeKey: BridgeKey
-  isProd: boolean
-  assetIn: Token | null
-}) => (
-  pathway(bridgeKey, isProd, assetIn?.address) ?? null
-)
+  bridgeKey: BridgeKey;
+  isProd: boolean;
+  assetIn: Token | null;
+}) => pathway(bridgeKey, isProd, assetIn?.address) ?? null;
 
 /**
  * Retrieves the amount to bridge from the amount and asset in. If either of them is nil, returns 0n
@@ -38,14 +44,14 @@ export const amountToBridge = ({
   amountIn,
   assetIn,
 }: {
-  amountIn: bigint | null
-  assetIn: Token | null
+  amountIn: bigint | null;
+  assetIn: Token | null;
 }) => {
   if (!amountIn || amountIn === 0n || !assetIn) {
-    return 0n
+    return 0n;
   }
-  return amountIn
-}
+  return amountIn;
+};
 
 /**
  * Calculates the bridge cost from the amount to bridge and bridge fee
@@ -57,12 +63,12 @@ export const bridgeCost = ({
   amountToBridge,
   bridgeFee,
 }: {
-  amountToBridge: bigint
-  bridgeFee: bigint | null
+  amountToBridge: bigint;
+  bridgeFee: bigint | null;
 }) => {
-  if (bridgeFee === null) return null
-  return (amountToBridge * bridgeFee) / oneEther
-}
+  if (bridgeFee === null) return null;
+  return (amountToBridge * bridgeFee) / oneEther;
+};
 
 /**
  * Calculates the amount after bridge fee from the amount to bridge and bridge cost
@@ -74,14 +80,14 @@ export const amountAfterBridgeFee = ({
   amountToBridge,
   bridgeCost,
 }: {
-  amountToBridge: bigint
-  bridgeCost: bigint | null
+  amountToBridge: bigint;
+  bridgeCost: bigint | null;
 }) => {
-  if (bridgeCost === null) return null
-  const afterFee = amountToBridge - bridgeCost
-  if (afterFee < 0n) return 0n
-  return afterFee
-}
+  if (bridgeCost === null) return null;
+  const afterFee = amountToBridge - bridgeCost;
+  if (afterFee < 0n) return 0n;
+  return afterFee;
+};
 
 /**
  * Calculates the estimated amount out from the amount after bridge fee and fee
@@ -93,14 +99,14 @@ export const estimatedAmountOut = ({
   amountAfterBridgeFee,
   fee,
 }: {
-  amountAfterBridgeFee: bigint | null
-  fee: bigint | null
+  amountAfterBridgeFee: bigint | null;
+  fee: bigint | null;
 }) => {
-  if (typeof fee !== 'bigint') return null
-  if (amountAfterBridgeFee === null) return null
-  if (fee > amountAfterBridgeFee) return 0n
-  return amountAfterBridgeFee - fee
-}
+  if (typeof fee !== 'bigint') return null;
+  if (amountAfterBridgeFee === null) return null;
+  if (fee > amountAfterBridgeFee) return 0n;
+  return amountAfterBridgeFee - fee;
+};
 
 /**
  * Calculates the estimated fee from the amount after bridge fee, fee, percent fee, fee type, limit, and whether to deliver the costs
@@ -120,27 +126,27 @@ export const estimatedFee = ({
   limit,
   costsToDeliver,
 }: {
-  amountAfterBridgeFee: bigint | null
-  fee: bigint
-  percentFee: bigint
-  feeType: FeeType
-  limit: bigint | null
-  costsToDeliver: boolean
+  amountAfterBridgeFee: bigint | null;
+  fee: bigint;
+  percentFee: bigint;
+  feeType: FeeType;
+  limit: bigint | null;
+  costsToDeliver: boolean;
 }) => {
-  const fixedFee = amountAfterBridgeFee ? (amountAfterBridgeFee * percentFee) / oneEther : null
+  const fixedFee = amountAfterBridgeFee ? (amountAfterBridgeFee * percentFee) / oneEther : null;
   if (!costsToDeliver) {
-    return 0n
+    return 0n;
   }
   if (feeType === FeeType.FIXED) {
-    return fee
+    return fee;
   } else if (feeType === FeeType.PERCENT) {
-    if (amountAfterBridgeFee === null) return null
-    return fixedFee
+    if (amountAfterBridgeFee === null) return null;
+    return fixedFee;
   } else if (feeType === FeeType.GAS_TIP) {
-    return limit
+    return limit;
   }
-  return null
-}
+  return null;
+};
 
 /**
  * Calculates the estimated native network cost from the estimated gas and latest base fee per gas
@@ -154,15 +160,15 @@ export const estimatedNativeNetworkCost = ({
   latestBaseFeePerGas,
   requiresDelivery,
 }: {
-  estimatedGas: bigint | null
-  latestBaseFeePerGas: bigint | null
-  requiresDelivery: boolean
+  estimatedGas: bigint | null;
+  latestBaseFeePerGas: bigint | null;
+  requiresDelivery: boolean;
 }) => {
   if (!estimatedGas || !latestBaseFeePerGas || !requiresDelivery) {
-    return null
+    return null;
   }
-  return BigInt(estimatedGas * latestBaseFeePerGas)
-}
+  return BigInt(estimatedGas * latestBaseFeePerGas);
+};
 
 /**
  * Calculates the estimated token network cost from the estimated native
@@ -179,31 +185,27 @@ export const estimatedTokenNetworkCost = ({
   decimals,
   oneTokenInt,
 }: {
-  estimatedNativeNetworkCost: bigint | null
-  priceCorrective: bigint | null
-  decimals: number | null
-  oneTokenInt: bigint | null
+  estimatedNativeNetworkCost: bigint | null;
+  priceCorrective: bigint | null;
+  decimals: number | null;
+  oneTokenInt: bigint | null;
 }) => {
   if (!priceCorrective || !oneTokenInt || !estimatedNativeNetworkCost || !decimals) {
-    return null
+    return null;
   }
-  const tokenCost = (estimatedNativeNetworkCost * oneTokenInt) / priceCorrective
-  return tokenCost
-}
+  const tokenCost = (estimatedNativeNetworkCost * oneTokenInt) / priceCorrective;
+  return tokenCost;
+};
 
 /**
  * Calculates one token of the asset in as an int
  * @param assetIn - the asset in to bridge
  * @returns the one token int
  */
-export const oneTokenInt = ({
-  assetIn,
-}: {
-  assetIn: Token | null
-}) => {
-  if (!assetIn) return 1n
-  return 10n ** BigInt(assetIn.decimals)
-}
+export const oneTokenInt = ({ assetIn }: { assetIn: Token | null }) => {
+  if (!assetIn) return 1n;
+  return 10n ** BigInt(assetIn.decimals);
+};
 
 /**
  * Returns the limit as a bigint. Nil uses 0n
@@ -212,10 +214,10 @@ export const oneTokenInt = ({
  */
 export const limit = (lim: bigint | null) => {
   if (!lim) {
-    return 0n
+    return 0n;
   }
-  return lim
-}
+  return lim;
+};
 
 /**
  * Returns the network switch asset out address from the asset out, unwrap, and to chain
@@ -229,14 +231,14 @@ export const networkSwitchAssetOutAddress = ({
   unwrap,
   toChain,
 }: {
-  assetOut: Token | null
-  unwrap: boolean
-  toChain: Chains
+  assetOut: Token | null;
+  unwrap: boolean;
+  toChain: Chains;
 }) => {
-  if (!assetOut) return null
-  if (!unwrap) return assetOut.address
-  return nativeAssetOut[toChain] === assetOut.address ? zeroAddress : assetOut.address
-}
+  if (!assetOut) return null;
+  if (!unwrap) return assetOut.address;
+  return nativeAssetOut[toChain] === assetOut.address ? zeroAddress : assetOut.address;
+};
 
 /**
  * Calculates the desired excess compensation basis points from the path, asset in, asset out, bridge key, fee type, list, and asset out address
@@ -258,30 +260,28 @@ export const desiredExcessCompensationBasisPoints = ({
   list,
   assetOutAddress,
 }: {
-  path: Pathway | null
-  assetIn: Token | null
-  assetOut: Token | null
-  bridgeKey: BridgeKey
-  feeType: FeeType
-  list: Set<string>
-  assetOutAddress: string | null
+  path: Pathway | null;
+  assetIn: Token | null;
+  assetOut: Token | null;
+  bridgeKey: BridgeKey;
+  feeType: FeeType;
+  list: Set<string>;
+  assetOutAddress: string | null;
 }) => {
   if (!path?.requiresDelivery) {
-    return 0n
+    return 0n;
   }
-  return (
-    !assetIn
-      ? 0n
-      : feeType === FeeType.PERCENT
+  return !assetIn
+    ? 0n
+    : feeType === FeeType.PERCENT
+      ? 1_000n
+      : isNative(assetIn, bridgeKey) || isNative(assetOut, bridgeKey)
         ? 1_000n
-        : isNative(assetIn, bridgeKey) || isNative(assetOut, bridgeKey)
-          ? 1_000n
-          : list.has(getAddress(assetIn?.address ?? '')) ||
+        : list.has(getAddress(assetIn?.address ?? '')) ||
             list.has(assetOutAddress ? getAddress(assetOutAddress) : '0x')
-            ? 5_000n
-            : 10_000n
-  )
-}
+          ? 5_000n
+          : 10_000n;
+};
 
 /**
  * Calculates the estimated cost from the should deliver, amount after bridge fee, percent fee,
@@ -302,29 +302,29 @@ export const estimatedCost = ({
   reasonablePercentOnTopOfGasFee,
   feeType,
 }: {
-  shouldDeliver: boolean
-  amountAfterBridgeFee: bigint | null
-  percentFee: bigint | null
-  estimatedTokenNetworkCost: bigint | null
-  reasonablePercentOnTopOfGasFee: bigint | null
-  feeType: FeeType
+  shouldDeliver: boolean;
+  amountAfterBridgeFee: bigint | null;
+  percentFee: bigint | null;
+  estimatedTokenNetworkCost: bigint | null;
+  reasonablePercentOnTopOfGasFee: bigint | null;
+  feeType: FeeType;
 }) => {
   if (!shouldDeliver) {
-    return null
+    return null;
   }
   if (feeType === FeeType.PERCENT) {
-    if (amountAfterBridgeFee === null) return null
-    return (amountAfterBridgeFee * (percentFee ?? 0n)) / oneEther
+    if (amountAfterBridgeFee === null) return null;
+    return (amountAfterBridgeFee * (percentFee ?? 0n)) / oneEther;
   }
   // gas tip
   if (!estimatedTokenNetworkCost) {
-    return null
+    return null;
   }
   if (!reasonablePercentOnTopOfGasFee) {
-    return null
+    return null;
   }
-  return estimatedTokenNetworkCost * (reasonablePercentOnTopOfGasFee + oneEther)
-}
+  return estimatedTokenNetworkCost * (reasonablePercentOnTopOfGasFee + oneEther);
+};
 
 /**
  * Calculates the reasonable fixed fee from the estimated token network cost and desired excess compensation basis points
@@ -336,17 +336,16 @@ export const reasonableFixedFee = ({
   estimatedTokenNetworkCost,
   desiredExcessCompensationBasisPoints,
 }: {
-  estimatedTokenNetworkCost: bigint | null
-  desiredExcessCompensationBasisPoints: bigint
+  estimatedTokenNetworkCost: bigint | null;
+  desiredExcessCompensationBasisPoints: bigint;
 }) => {
   if (!estimatedTokenNetworkCost) {
-    return null
+    return null;
   }
   return (
-    (estimatedTokenNetworkCost * (25_000n + desiredExcessCompensationBasisPoints)) /
-    basisPoints
-  )
-}
+    (estimatedTokenNetworkCost * (25_000n + desiredExcessCompensationBasisPoints)) / basisPoints
+  );
+};
 
 /**
  * Calculates the reasonable percent on gas limit from the gas tip fee and estimated token network cost
@@ -358,15 +357,14 @@ export const reasonablePercentOnGasLimit = ({
   gasTipFee,
   estimatedTokenNetworkCost,
 }: {
-  gasTipFee: bigint | null
-  estimatedTokenNetworkCost: bigint | null
+  gasTipFee: bigint | null;
+  estimatedTokenNetworkCost: bigint | null;
 }) => {
   return (
-    (25_000n *
-      ((oneEther + (gasTipFee ?? 0n)) * (estimatedTokenNetworkCost ?? 0n))) /
+    (25_000n * ((oneEther + (gasTipFee ?? 0n)) * (estimatedTokenNetworkCost ?? 0n))) /
     (oneEther * basisPoints)
-  )
-}
+  );
+};
 
 /**
  * Calculates the reasonable percent fee from the reasonable fixed fee and amount after bridge fee
@@ -378,31 +376,31 @@ export const reasonablePercentFee = ({
   reasonableFixedFee,
   amountAfterBridgeFee,
 }: {
-  reasonableFixedFee: bigint | null
-  amountAfterBridgeFee: bigint | null
+  reasonableFixedFee: bigint | null;
+  amountAfterBridgeFee: bigint | null;
 }) => {
   if (!reasonableFixedFee) {
-    return null
+    return null;
   }
   if (!amountAfterBridgeFee) {
-    return null
+    return null;
   }
-  const highFee = amountAfterBridgeFee / 10n
-  const basisFeeTruncator = 10n ** 14n
-  const max = 1_000n * basisFeeTruncator
-  const min = 5n * basisFeeTruncator
+  const highFee = amountAfterBridgeFee / 10n;
+  const basisFeeTruncator = 10n ** 14n;
+  const max = 1_000n * basisFeeTruncator;
+  const min = 5n * basisFeeTruncator;
   if (highFee < reasonableFixedFee) {
-    return max // 10%
+    return max; // 10%
   }
-  const highResPercent = (reasonableFixedFee * oneEther) / amountAfterBridgeFee
+  const highResPercent = (reasonableFixedFee * oneEther) / amountAfterBridgeFee;
   if (highResPercent < min) {
-    return min
+    return min;
   } else if (highResPercent > max) {
-    return max
+    return max;
   }
-  const basisPoint = highResPercent / basisFeeTruncator
-  return basisPoint * basisFeeTruncator
-}
+  const basisPoint = highResPercent / basisFeeTruncator;
+  return basisPoint * basisFeeTruncator;
+};
 
 /**
  * Returns whether the asset in address is interacting with a bridge token
@@ -414,18 +412,18 @@ export const interactingWithBridgeToken = ({
   assetLink,
   assetInAddress,
 }: {
-  assetLink: TokenBridgeInfo | null
-  assetInAddress: string | null
+  assetLink: TokenBridgeInfo | null;
+  assetInAddress: string | null;
 }) => {
-  const { toForeign, toHome } = assetLink || {}
-  const { foreign } = toForeign || {}
-  const { home } = toHome || {}
-  if (!assetInAddress) return false
+  const { toForeign, toHome } = assetLink || {};
+  const { foreign } = toForeign || {};
+  const { home } = toHome || {};
+  if (!assetInAddress) return false;
   return !!(
     (foreign && getAddress(foreign) === getAddress(assetInAddress)) ||
     (home && getAddress(home) === getAddress(assetInAddress))
-  )
-}
+  );
+};
 
 /**
  * Calculates the fee director struct encoded from the recipient, bridge pathway, fee type, price corrective, gas tip fee, percent fee, fee type settings, limit, and asset out
@@ -451,40 +449,39 @@ export const feeDirectorStructEncoded = ({
   limit,
   assetOut,
 }: {
-  recipient: Hex | null
-  feeType: FeeType
-  priceCorrective: bigint | null
-  gasTipFee: bigint | null
-  percentFee: bigint | null
-  feeTypeSettings: bigint
-  limit: bigint
-  bridgePathway: Pathway | null
-  assetOut: Token | null
+  recipient: Hex | null;
+  feeType: FeeType;
+  priceCorrective: bigint | null;
+  gasTipFee: bigint | null;
+  percentFee: bigint | null;
+  feeTypeSettings: bigint;
+  limit: bigint;
+  bridgePathway: Pathway | null;
+  assetOut: Token | null;
 }) => {
   if (!assetOut || !bridgePathway) {
-    return null
+    return null;
   }
   if (!bridgePathway.requiresDelivery) {
-    return null
+    return null;
   }
   if (!priceCorrective) {
-    return null
+    return null;
   }
-  let multiplier = 0n
+  let multiplier = 0n;
   if (feeType === FeeType.GAS_TIP && priceCorrective > 0n) {
     multiplier =
-      ((oneEther + (gasTipFee ?? 0n)) * 10n ** BigInt(assetOut.decimals)) /
-      priceCorrective
+      ((oneEther + (gasTipFee ?? 0n)) * 10n ** BigInt(assetOut.decimals)) / priceCorrective;
   } else if (feeType === FeeType.PERCENT) {
-    multiplier = percentFee ?? 0n
+    multiplier = percentFee ?? 0n;
   }
   if (!recipient || !isAddress(recipient)) {
-    return null
+    return null;
   }
   return encodeAbiParameters(abis.feeDeliveryStruct, [
     [recipient, feeTypeSettings, limit, multiplier],
-  ])
-}
+  ]);
+};
 
 /**
  * Calculates the destination data param from the recipient, bridge pathway, asset in, destination router, fee director struct encoded, asset link, should deliver, and unwrap
@@ -508,52 +505,52 @@ export const destinationDataParam = ({
   shouldDeliver,
   unwrap,
 }: {
-  recipient: Hex | null
-  bridgePathway: Pathway | null
-  assetIn: Token | null
-  destinationRouter: Hex | null
-  feeDirectorStructEncoded: Hex | null
-  assetLink: TokenBridgeInfo | null
-  shouldDeliver: boolean
-  unwrap: boolean
+  recipient: Hex | null;
+  bridgePathway: Pathway | null;
+  assetIn: Token | null;
+  destinationRouter: Hex | null;
+  feeDirectorStructEncoded: Hex | null;
+  assetLink: TokenBridgeInfo | null;
+  shouldDeliver: boolean;
+  unwrap: boolean;
 }) => {
   // const recipient = input.recipient.value
   if (!recipient) {
-    return null
+    return null;
   }
   if (!bridgePathway || !assetIn) {
-    return null
+    return null;
   }
   if (!destinationRouter) {
-    console.log('no destination router')
-    return null
+    console.log('no destination router');
+    return null;
   }
   if (bridgePathway.requiresDelivery && !feeDirectorStructEncoded) {
-    console.log('no fee director struct encoded')
-    return null
+    console.log('no fee director struct encoded');
+    return null;
   }
   if (!assetLink) {
-    console.log('no asset link')
-    return null
+    console.log('no asset link');
+    return null;
   }
   if (bridgePathway.requiresDelivery) {
     // going from home to foreign
     if (!shouldDeliver) {
       // act like a regular bridge
-      return recipient
+      return recipient;
     }
     // going from foreign to home
     if (feeDirectorStructEncoded) {
-      return concatHex([destinationRouter, feeDirectorStructEncoded])
+      return concatHex([destinationRouter, feeDirectorStructEncoded]);
     }
-    return recipient
+    return recipient;
   }
   if (!unwrap) {
-    return recipient
+    return recipient;
   }
   // unwrap wpls->pls
-  return concatHex([destinationRouter, recipient])
-}
+  return concatHex([destinationRouter, recipient]);
+};
 
 /**
  * Converts a desired excess compensation basis point value into a percentage as an integer, with the denominator assumed to be 1e18
@@ -563,10 +560,10 @@ export const destinationDataParam = ({
 export const reasonablePercentOnTopOfGasFee = ({
   desiredExcessCompensationBasisPoints,
 }: {
-  desiredExcessCompensationBasisPoints: bigint
+  desiredExcessCompensationBasisPoints: bigint;
 }) => {
-  return (desiredExcessCompensationBasisPoints * (oneEther / basisPoints))
-}
+  return desiredExcessCompensationBasisPoints * (oneEther / basisPoints);
+};
 
 /**
  * Calculates the desired compensation ratio from the desired excess compensation basis points
@@ -576,10 +573,10 @@ export const reasonablePercentOnTopOfGasFee = ({
 export const desiredCompensationRatio = ({
   desiredExcessCompensationBasisPoints,
 }: {
-  desiredExcessCompensationBasisPoints: bigint
+  desiredExcessCompensationBasisPoints: bigint;
 }) => {
-  return oneEther + (desiredExcessCompensationBasisPoints * oneEther) / basisPoints
-}
+  return oneEther + (desiredExcessCompensationBasisPoints * oneEther) / basisPoints;
+};
 
 /**
  * Calculates the available compensation maximum from the amount after bridge fee, percent fee, fee type, fixed fee, and limit
@@ -597,22 +594,69 @@ export const availableCompensationMaximum = ({
   fixedFee,
   limit,
 }: {
-  amountAfterBridgeFee: bigint | null
-  percentFee: bigint | null
-  feeType: FeeType
-  fixedFee: bigint | null
-  limit: bigint
+  amountAfterBridgeFee: bigint | null;
+  percentFee: bigint | null;
+  feeType: FeeType;
+  fixedFee: bigint | null;
+  limit: bigint;
 }) => {
   if (feeType === FeeType.PERCENT) {
-    if (amountAfterBridgeFee === null) return null
-    return (amountAfterBridgeFee * (percentFee ?? 0n)) / oneEther
+    if (amountAfterBridgeFee === null) return null;
+    return (amountAfterBridgeFee * (percentFee ?? 0n)) / oneEther;
   } else if (feeType === FeeType.GAS_TIP) {
-    return limit
+    return limit;
   } else if (feeType === FeeType.FIXED) {
-    return fixedFee ?? 0n
+    return fixedFee ?? 0n;
+  }
+  return 0n;
+};
+
+/**
+ * Determines if the bridge is undercompensated based on network costs vs compensation limit using desired compensation rate
+ * @param estimatedTokenNetworkCost - the estimated token network cost
+ * @param feeType - the fee type
+ * @param limit - the maximum compensation limit
+ * @param amountAfterBridgeFee - the amount after bridge fee
+ * @param desiredExcessCompensationBasisPoints - the desired excess compensation basis points
+ * @returns whether the bridge is undercompensated
+ */
+export const isUndercompensated = ({
+  estimatedTokenNetworkCost,
+  feeType,
+  limit,
+  amountAfterBridgeFee,
+  desiredExcessCompensationBasisPoints,
+}: {
+  estimatedTokenNetworkCost: bigint | null;
+  feeType: FeeType;
+  limit: bigint;
+  amountAfterBridgeFee: bigint | null;
+  desiredExcessCompensationBasisPoints: bigint;
+}) => {
+  // No undercompensation if no amount to bridge
+  if (!amountAfterBridgeFee || amountAfterBridgeFee <= 0n) {
+    return false;
+  }
+
+  // GAS_TIP fee type doesn't have undercompensation issues
+  if (feeType === FeeType.GAS_TIP) {
+    return false;
   }
-  return 0n
-}
+
+  // No network cost estimate means we can't determine undercompensation
+  if (!estimatedTokenNetworkCost) {
+    return false;
+  }
+
+  // Calculate desired compensation using the actual desired compensation ratio
+  const desiredCompensationRatio =
+    oneEther + (desiredExcessCompensationBasisPoints * oneEther) / basisPoints;
+  const desiredCompensationForNetworkCost =
+    (estimatedTokenNetworkCost * desiredCompensationRatio) / oneEther;
+
+  // Undercompensated if desired compensation exceeds the limit
+  return desiredCompensationForNetworkCost > limit;
+};
 
 /**
  * Calculates the transaction inputs from the bridge pathway, asset in, recipient, account, asset link, destination data param, amount to bridge, fee director struct encoded, and should deliver
@@ -638,170 +682,148 @@ export const transactionInputs = ({
   feeDirectorStructEncoded,
   shouldDeliver,
 }: {
-  bridgePathway: Pathway | null
-  assetIn: Token | null
-  recipient: Hex | null
-  account: Hex | null
-  assetLink: TokenBridgeInfo | null
-  destinationDataParam: Hex | null
-  amountToBridge: bigint
-  feeDirectorStructEncoded: Hex | null
-  shouldDeliver: boolean
+  bridgePathway: Pathway | null;
+  assetIn: Token | null;
+  recipient: Hex | null;
+  account: Hex | null;
+  assetLink: TokenBridgeInfo | null;
+  destinationDataParam: Hex | null;
+  amountToBridge: bigint;
+  feeDirectorStructEncoded: Hex | null;
+  shouldDeliver: boolean;
 }) => {
   if (!bridgePathway) {
-    console.log('no bridge pathway')
-    return null
+    console.log('no bridge pathway');
+    return null;
   }
   // check that recipient is valid
-  if (
-    !recipient ||
-    !isAddress(recipient) ||
-    account === zeroAddress
-  ) {
-    console.log('no recipient')
-    return null
+  if (!recipient || !isAddress(recipient) || recipient === zeroAddress) {
+    console.log('no recipient');
+    return null;
   }
   // check that wallet account is valid
-  if (
-    !account ||
-    !isAddress(account) ||
-    account === zeroAddress
-  ) {
-    console.log('no account')
-    return null
+  if (!account || !isAddress(account) || account === zeroAddress) {
+    console.log('no account');
+    return null;
   }
   // check that asset in is valid
   if (!assetIn) {
-    console.log('no asset in')
-    return null
+    console.log('no asset in');
+    return null;
   }
   // check that asset link is valid
   if (!assetLink) {
-    console.log('no asset link')
-    return null
+    console.log('no asset link');
+    return null;
   }
-  let value = 0n
+  let value = 0n;
   // we are moving "from" this side, so we need to call a function on the "from" address
   // only relevant for the relayTokens(AndCall) pathway outside of native tokens
-  let toAddress = bridgePathway.from
-  let data = '0x' as Hex
+  let toAddress = bridgePathway.from;
+  let data = '0x' as Hex;
   const inputIsBridgeToken = interactingWithBridgeToken({
     assetLink,
     assetInAddress: assetIn.address,
-  })
+  });
   if (inputIsBridgeToken) {
     // when interacting with a bridged token, we need to call the token address directly
-    toAddress = assetIn.address as Hex
-    value = 0n
+    toAddress = assetIn.address as Hex;
+    value = 0n;
     // if we want delivery of the tokens (going from home to foreign) then we need to have the foreign data param
     // and it needs to start with the destination router
     if (!destinationDataParam) {
-      return null
+      return null;
     }
     data = bridgePathway.usesExtraParam
       ? encodeFunctionData({
-        abi: abis.erc677ExtraInput,
-        functionName: 'transferAndCall',
-        args: [
-          bridgePathway.from,
-          amountToBridge,
-          destinationDataParam,
-          account,
-        ],
-      })
+          abi: abis.erc677ExtraInput,
+          functionName: 'transferAndCall',
+          args: [bridgePathway.from, amountToBridge, destinationDataParam, account],
+        })
       : encodeFunctionData({
-        abi: abis.erc677,
-        functionName: 'transferAndCall',
-        args: [bridgePathway.from, amountToBridge, destinationDataParam],
-      })
+          abi: abis.erc677,
+          functionName: 'transferAndCall',
+          args: [bridgePathway.from, amountToBridge, destinationDataParam],
+        });
   } else if (assetIn.address === zeroAddress) {
-    value = amountToBridge
-    toAddress = bridgePathway.nativeRouter
+    value = amountToBridge;
+    toAddress = bridgePathway.nativeRouter;
     if (bridgePathway.feeManager === 'from' && shouldDeliver) {
       // transferring native to foreign
-      if (!feeDirectorStructEncoded) return null
-      if (!bridgePathway.destinationRouter) return null
+      if (!feeDirectorStructEncoded) return null;
+      if (!bridgePathway.destinationRouter) return null;
       data = bridgePathway.usesExtraParam
         ? encodeFunctionData({
-          abi: abis.nativeRouterExtraInput,
-          functionName: 'relayTokensAndCall',
-          args: [
-            bridgePathway.destinationRouter,
-            feeDirectorStructEncoded,
-            account,
-          ],
-        })
+            abi: abis.nativeRouterExtraInput,
+            functionName: 'relayTokensAndCall',
+            args: [bridgePathway.destinationRouter, feeDirectorStructEncoded, account],
+          })
         : encodeFunctionData({
-          abi: abis.nativeRouter,
-          functionName: 'relayTokensAndCall',
-          args: [bridgePathway.destinationRouter, feeDirectorStructEncoded],
-        })
+            abi: abis.nativeRouter,
+            functionName: 'relayTokensAndCall',
+            args: [bridgePathway.destinationRouter, feeDirectorStructEncoded],
+          });
     } else {
       // delivery always occurs when moving from foreign to home
       data = bridgePathway.usesExtraParam
         ? encodeFunctionData({
-          abi: abis.nativeRouterExtraInput,
-          functionName: 'wrapAndRelayTokens',
-          args: [recipient, account],
-        })
+            abi: abis.nativeRouterExtraInput,
+            functionName: 'wrapAndRelayTokens',
+            args: [recipient, account],
+          })
         : encodeFunctionData({
-          abi: abis.nativeRouter,
-          functionName: 'wrapAndRelayTokens',
-          args: [recipient],
-        })
+            abi: abis.nativeRouter,
+            functionName: 'wrapAndRelayTokens',
+            args: [recipient],
+          });
     }
   } else {
     // tokens native to this side, entering the bridge
     if (shouldDeliver && bridgePathway.requiresDelivery) {
-      if (!feeDirectorStructEncoded) return null
-      if (!bridgePathway.destinationRouter) return null
+      if (!feeDirectorStructEncoded) return null;
+      if (!bridgePathway.destinationRouter) return null;
       data = bridgePathway.usesExtraParam
         ? encodeFunctionData({
-          abi: abis.inputBridgeExtraInput,
-          functionName: 'relayTokensAndCall',
-          args: [
-            assetIn.address as Hex,
-            bridgePathway.destinationRouter,
-            amountToBridge,
-            feeDirectorStructEncoded,
-            account,
-          ],
-        })
+            abi: abis.inputBridgeExtraInput,
+            functionName: 'relayTokensAndCall',
+            args: [
+              assetIn.address as Hex,
+              bridgePathway.destinationRouter,
+              amountToBridge,
+              feeDirectorStructEncoded,
+              account,
+            ],
+          })
         : encodeFunctionData({
-          abi: abis.inputBridge,
-          functionName: 'relayTokensAndCall',
-          args: [
-            assetIn.address as Hex,
-            bridgePathway.destinationRouter,
-            amountToBridge,
-            feeDirectorStructEncoded,
-          ],
-        })
+            abi: abis.inputBridge,
+            functionName: 'relayTokensAndCall',
+            args: [
+              assetIn.address as Hex,
+              bridgePathway.destinationRouter,
+              amountToBridge,
+              feeDirectorStructEncoded,
+            ],
+          });
     } else {
       data = bridgePathway.usesExtraParam
         ? encodeFunctionData({
-          abi: abis.inputBridgeExtraInput,
-          functionName: 'relayTokens',
-          args: [
-            assetIn.address as Hex,
-            recipient,
-            amountToBridge,
-            account,
-          ],
-        })
+            abi: abis.inputBridgeExtraInput,
+            functionName: 'relayTokens',
+            args: [assetIn.address as Hex, recipient, amountToBridge, account],
+          })
         : encodeFunctionData({
-          abi: abis.inputBridge,
-          functionName: 'relayTokens',
-          args: [assetIn.address as Hex, recipient, amountToBridge],
-        })
+            abi: abis.inputBridge,
+            functionName: 'relayTokens',
+            args: [assetIn.address as Hex, recipient, amountToBridge],
+          });
     }
   }
   return {
     to: toAddress,
     value,
     data,
-  }
-}
+  };
+};
 
 /**
  * Calculates the asset out key from the bridge key path, asset in address, and unwrap
@@ -815,13 +837,13 @@ export const assetOutKey = ({
   assetInAddress,
   unwrap,
 }: {
-  bridgeKeyPath: string
-  assetInAddress?: Hex | null
-  unwrap: boolean
+  bridgeKeyPath: string;
+  assetInAddress?: Hex | null;
+  unwrap: boolean;
 }) => {
-  if (!bridgeKeyPath || !assetInAddress) return null
-  return `${bridgeKeyPath}/${unwrap ? 'native' : 'erc20'}/${assetInAddress.toLowerCase()}`
-}
+  if (!bridgeKeyPath || !assetInAddress) return null;
+  return `${bridgeKeyPath}/${unwrap ? 'native' : 'erc20'}/${assetInAddress.toLowerCase()}`;
+};
 
 /**
  * Returns the asset out from the asset in address, assets out, bridge key path, and unwrap
@@ -837,17 +859,17 @@ export const assetOut = ({
   bridgeKeyPath,
   unwrap,
 }: {
-  assetInAddress: Hex | null
-  assetsOut: Map<string, Token>
-  bridgeKeyPath: string
-  unwrap: boolean
+  assetInAddress: Hex | null;
+  assetsOut: Map<string, Token>;
+  bridgeKeyPath: string;
+  unwrap: boolean;
 }) => {
-  if (!assetInAddress) return null
+  if (!assetInAddress) return null;
   const key = assetOutKey({
     bridgeKeyPath,
     assetInAddress,
     unwrap,
-  })
-  if (!key) return null
-  return assetsOut.get(key) ?? null
-}
+  });
+  if (!key) return null;
+  return assetsOut.get(key) ?? null;
+};