feat: add swap strategy

packages/filler/src/services/ContractInteractionService.ts

@@ -399,4 +399,59 @@ export class ContractInteractionService {
 		})
 		return hostParams
 	}
+
+	async getTokenUsdValue(order: Order): Promise<{ outputUsdValue: bigint; inputUsdValue: bigint }> {
+		let outputUsdValue = BigInt(0)
+		let inputUsdValue = BigInt(0)
+		const outputs = order.outputs
+		const inputs = order.inputs
+
+		for (const output of outputs) {
+			const tokenAddress = bytes32ToBytes20(output.token)
+			const amount = output.amount
+			const price = await this.getTokenPrice(tokenAddress, order.destChain)
+			outputUsdValue = outputUsdValue + amount * price
+		}
+
+		for (const input of inputs) {
+			const tokenAddress = bytes32ToBytes20(input.token)
+			const amount = input.amount
+			const price = await this.getTokenPrice(tokenAddress, order.sourceChain)
+			inputUsdValue = inputUsdValue + amount * price
+		}
+
+		return { outputUsdValue, inputUsdValue }
+	}
+
+	async getTokenPrice(tokenAddress: string, chain: string): Promise<bigint> {
+		const decimals = await this.getTokenDecimals(tokenAddress, chain)
+		const usdValue = await fetchTokenUsdPriceOnchain(tokenAddress, decimals)
+		return usdValue
+	}
+
+	async getFillerBalanceUSD(order: Order, chain: string): Promise<bigint> {
+		// As part of the protocol, the filler will have only two tokens:
+		// 1. The native token of the chain. And 2. DAI
+		// We need to get the balance of the filler in both tokens
+		// and convert them to USD
+		const fillerWalletAddress = privateKeyToAddress(this.privateKey)
+		const destClient = this.clientManager.getPublicClient(chain)
+		// Native token balance
+		const nativeTokenBalance = await destClient.getBalance({ address: fillerWalletAddress })
+		const nativeTokenPriceUsd = await this.getNativeTokenPriceUsd(order)
+		const nativeTokenUsdValue = nativeTokenBalance * nativeTokenPriceUsd
+
+		// DAI balance
+		const daiBalance = await destClient.readContract({
+			abi: ERC20_ABI,
+			address: this.configService.getDaiAsset(chain),
+			functionName: "balanceOf",
+			args: [fillerWalletAddress],
+		})
+
+		const daiPriceUsd = await this.getTokenPrice(this.configService.getDaiAsset(chain), chain)
+		const daiUsdValue = daiBalance * daiPriceUsd
+
+		return nativeTokenUsdValue + daiUsdValue
+	}
 }

packages/filler/src/strategies/swap.ts

@@ -0,0 +1,243 @@
+import { ChainConfigService, ChainClientManager, ContractInteractionService } from "@/services"
+import {
+	bytes32ToBytes20,
+	constructRedeemEscrowRequestBody,
+	estimateGasForPost,
+	ExecutionResult,
+	FillOptions,
+	HexString,
+	IPostRequest,
+	Order,
+} from "hyperbridge-sdk"
+import { FillerStrategy } from "./base"
+import { privateKeyToAccount, privateKeyToAddress } from "viem/accounts"
+import { INTENT_GATEWAY_ABI } from "@/config/abis/IntentGateway"
+import { get1inchExactOutputQuote } from "@/utils"
+import { encodeFunctionData } from "viem"
+import { erc7821Actions } from "viem/experimental"
+
+export class BasicFiller implements FillerStrategy {
+	name = "BasicFiller"
+	private privateKey: HexString
+	private clientManager: ChainClientManager
+	private contractService: ContractInteractionService
+	private configService: ChainConfigService
+
+	constructor(privateKey: HexString) {
+		this.privateKey = privateKey
+		this.configService = new ChainConfigService()
+		this.clientManager = new ChainClientManager(privateKey)
+		this.contractService = new ContractInteractionService(this.clientManager, privateKey)
+	}
+
+	/**
+	 * Checks the USD value of the filler's balance against the order's USD value
+	 * @param order The order to check if it can be filled
+	 * @returns True if the filler has enough balance, false otherwise
+	 */
+	async canFill(order: Order): Promise<boolean> {
+		try {
+			const destClient = this.clientManager.getPublicClient(order.destChain)
+			const currentBlock = await destClient.getBlockNumber()
+			const deadline = BigInt(order.deadline)
+
+			if (deadline < currentBlock) {
+				console.debug(`Order expired at block ${deadline}, current block ${currentBlock}`)
+				return false
+			}
+
+			const isAlreadyFilled = await this.contractService.checkIfOrderFilled(order)
+			if (isAlreadyFilled) {
+				console.debug(`Order is already filled`)
+				return false
+			}
+
+			const fillerBalanceUsd = await this.contractService.getFillerBalanceUSD(order, order.destChain)
+
+			// Check if the filler has enough USD value to fill the order
+			const { outputUsdValue } = await this.contractService.getTokenUsdValue(order)
+
+			if (fillerBalanceUsd < outputUsdValue) {
+				console.debug(`Insufficient USD value for order`)
+				return false
+			}
+
+			return true
+		} catch (error) {
+			console.error(`Error in canFill:`, error)
+			return false
+		}
+	}
+
+	/**
+	 * Calculates the USD value of the order's inputs, outputs, fees and compares
+	 * what will the filler receive and what will the filler pay
+	 * @param order The order to calculate the USD value for
+	 * @returns The profit in USD (BigInt)
+	 */
+	async calculateProfitability(order: Order): Promise<bigint> {
+		try {
+			const { fillGas, postGas } = await this.contractService.estimateGasFillPost(order)
+			const nativeTokenPriceUsd = await this.contractService.getNativeTokenPriceUsd(order)
+
+			const relayerFeeEth = postGas + (postGas * BigInt(200)) / BigInt(10000)
+
+			const protocolFeeUSD = await this.contractService.getProtocolFeeUSD(order, relayerFeeEth)
+
+			const totalGasWei = fillGas + relayerFeeEth
+
+			const gasCostUsd = (totalGasWei * nativeTokenPriceUsd) / BigInt(10 ** 18)
+
+			const totalGasCostUsd = gasCostUsd + protocolFeeUSD
+
+			const { outputUsdValue, inputUsdValue } = await this.contractService.getTokenUsdValue(order)
+
+			const toReceive = outputUsdValue + order.fees
+			const toPay = inputUsdValue + totalGasCostUsd
+
+			const profit = toReceive - toPay
+
+			return profit
+		} catch (error) {
+			console.error(`Error calculating profitability:`, error)
+			return BigInt(0)
+		}
+	}
+
+	async executeOrder(order: Order): Promise<ExecutionResult> {
+		try {
+			const { destClient, walletClient } = this.clientManager.getClientsForOrder(order)
+			const startTime = Date.now()
+
+			const fillerWalletAddress = privateKeyToAddress(this.privateKey)
+
+			const operations: { calls: { to: HexString; data: HexString; value?: bigint }[] }[] = []
+
+			for (const token of order.outputs) {
+				const tokenAddress = bytes32ToBytes20(token.token)
+				const tokenBalance = await this.contractService.getTokenBalance(
+					tokenAddress,
+					fillerWalletAddress,
+					order.destChain,
+				)
+				if (tokenBalance === BigInt(0)) {
+					const chainId = Number(order.destChain.split("-")[1])
+
+					const swapData = await get1inchExactOutputQuote({
+						chainId,
+						srcToken: this.configService.getDaiAsset(order.destChain),
+						dstToken: tokenAddress,
+						amount: token.amount.toString(),
+						fromAddress: fillerWalletAddress,
+						slippage: 200,
+						isExactOut: true,
+					})
+
+					try {
+						// Simulating individual swaps for early debugging
+						await destClient.simulateCalls({
+							account: fillerWalletAddress,
+							calls: [
+								{
+									to: swapData.tx.to as HexString,
+									data: swapData.tx.data as HexString,
+									value: BigInt(swapData.tx.value || 0),
+								},
+							],
+						})
+
+						operations.push({
+							calls: [
+								{
+									to: swapData.tx.to as HexString,
+									data: swapData.tx.data as HexString,
+									value: BigInt(swapData.tx.value || 0),
+								},
+							],
+						})
+					} catch (simulationError) {
+						console.error("Swap simulation failed:", simulationError)
+						throw new Error("Swap simulation failed")
+					}
+				}
+			}
+
+			const postRequest: IPostRequest = {
+				source: order.destChain,
+				dest: order.sourceChain,
+				body: constructRedeemEscrowRequestBody(order, privateKeyToAddress(this.privateKey)),
+				timeoutTimestamp: 0n,
+				nonce: await this.contractService.getHostNonce(order.sourceChain),
+				from: this.configService.getIntentGatewayAddress(order.sourceChain),
+				to: this.configService.getIntentGatewayAddress(order.destChain),
+			}
+
+			const postGasEstimate = await estimateGasForPost({
+				postRequest: postRequest,
+				sourceClient: this.clientManager.getPublicClient(order.sourceChain) as any,
+				hostLatestStateMachineHeight: await this.contractService.getHostLatestStateMachineHeight(),
+				hostAddress: this.configService.getHostAddress(order.sourceChain),
+			})
+			const fillOptions: FillOptions = {
+				relayerFee: postGasEstimate + (postGasEstimate * BigInt(200)) / BigInt(10000),
+			}
+
+			await this.contractService.approveTokensIfNeeded(order)
+
+			const fillOrderData = encodeFunctionData({
+				abi: INTENT_GATEWAY_ABI,
+				functionName: "fillOrder",
+				args: [this.contractService.transformOrderForContract(order), fillOptions as any],
+			})
+
+			operations.push({
+				calls: [
+					{
+						to: this.configService.getIntentGatewayAddress(order.destChain),
+						data: fillOrderData,
+						value: this.contractService.calculateRequiredEthValue(order.outputs),
+					},
+				],
+			})
+
+			try {
+				// Simulating all calls together
+				await destClient.simulateCalls({
+					account: fillerWalletAddress,
+					calls: operations.flatMap((op) => op.calls),
+				})
+			} catch (batchSimulationError) {
+				console.error("Batch simulation failed:", batchSimulationError)
+				throw new Error("Batch simulation failed")
+			}
+
+			const tx = await walletClient.extend(erc7821Actions()).executeBatches({
+				address: fillerWalletAddress,
+				batches: operations,
+				account: privateKeyToAccount(this.privateKey),
+				chain: destClient.chain,
+			})
+
+			const endTime = Date.now()
+			const processingTimeMs = endTime - startTime
+
+			const receipt = await destClient.waitForTransactionReceipt({ hash: tx })
+
+			return {
+				success: true,
+				txHash: receipt.transactionHash,
+				gasUsed: receipt.gasUsed.toString(),
+				gasPrice: receipt.effectiveGasPrice.toString(),
+				confirmedAtBlock: Number(receipt.blockNumber),
+				confirmedAt: new Date(),
+				strategyUsed: this.name,
+				processingTimeMs,
+			}
+		} catch (error) {
+			console.error(`Error executing order:`, error)
+			return {
+				success: false,
+			}
+		}
+	}
+}

packages/filler/src/utils.ts

@@ -21,3 +21,37 @@ export async function fetchTokenUsdPriceOnchain(address: string, decimals: numbe
 		throw error
 	}
 }
+
+export async function get1inchExactOutputQuote(params: {
+	chainId: number
+	srcToken: string
+	dstToken: string
+	amount: string
+	fromAddress: string
+	slippage: number
+	isExactOut: boolean
+}) {
+	const API_URL = `https://api.1inch.io/v5.0/${params.chainId}/swap`
+
+	const queryParams = new URLSearchParams({
+		fromTokenAddress: params.srcToken,
+		toTokenAddress: params.dstToken,
+		fromAddress: params.fromAddress,
+		slippage: params.slippage.toString(),
+		disableEstimate: "true",
+		protocols: "DEXES",
+	})
+
+	// Handle exact output case
+	if (params.isExactOut) {
+		queryParams.set("destAmount", params.amount)
+	} else {
+		queryParams.set("amount", params.amount)
+	}
+
+	const response = await fetch(`${API_URL}?${queryParams}`)
+	if (!response.ok) {
+		throw new Error(`1inch API error: ${await response.text()}`)
+	}
+	return await response.json()
+}