The contract X7DAOLiquidityHub is a smart contract for managing a liquidity pool on a decentralized exchange (DEX). The contract includes several interfaces for interacting with other contracts, including IUniswapV2Router for interacting with the V2 DEX, ILiquidityHub for defining functions that can be called by other contracts to process fees, and IERC20 for interacting with ERC20 tokens.
The contract has several variables that define the behavior of the liquidity pool, such as liquidityRatioTarget, minShare, and maxShare. It also has variables for tracking the balances of various accounts, including distributeBalance, auxiliaryBalance, and treasuryBalance.
The setShares function is a function for adjusting the distribution of fees between different accounts. The function takes four arguments: distributeShare_, liquidityShare_, auxiliaryShare_, and treasuryShare_. These arguments represent the percentage of fees that should be allocated to the distribute account, the liquidity account, the auxiliary account, and the treasury account, respectively.
The function first checks that the total percentage of fees being allocated adds up to 1000. It then checks that each of the individual shares is within a certain range (specified by the minShare and maxShare variables). If these checks pass, the function updates the values of the distributeShare, liquidityShare, auxiliaryShare, and treasuryShare variables and emits a SharesSet event.
This function can only be called by the contract owner.
The setRouter function is a function for setting the address of the IUniswapV2Router contract that the X7DAOLiquidityHub contract should use for interacting with the V2 DEX. The function takes a single argument, router_, which is the address of the IUniswapV2Router contract.
The function first checks that the provided address is not the same as the current router address. It then assigns the provided address to the router variable and emits a RouterSet event.
This function can only be called by the contract owner.
The setOffRampPair function is a function for setting the address of the V2 pair that should be used for off-ramp liquidity. The function takes a single argument, offRampPairAddress, which is the address of the V2 pair.
The function first checks that the provided address is not the same as the current off-ramp pair address. It then assigns the provided address to the offRampPair variable and emits an OffRampPairSet event.
This function can only be called by the contract owner.
The setBalanceThreshold function is a function for setting the balance threshold for the X7DAOLiquidityHub contract. The balance threshold is the minimum balance that must be reached in the contract before fees can be processed and distributed to the various accounts.
The function takes a single argument, threshold, which is the new balance threshold. The function first checks that the balanceThresholdFrozen variable is not set (which indicates that the balance threshold can be modified). It then updates the value of the balanceThreshold variable and emits a BalanceThresholdSet event.
This function can only be called by the contract owner.
The setLiquidityRatioTarget function is a function for setting the target liquidity ratio for the X7DAOLiquidityHub contract. The liquidity ratio is the ratio of liquidity tokens (tokens representing ownership of the liquidity pool) to underlying tokens in the liquidity pool.
The function takes a single argument, liquidityRatioTarget_, which is the new target liquidity ratio. The function first checks that the provided target is not the same as the current target, and that it falls within a certain range (specified by the minLiquidityRatioTarget and maxLiquidityRatioTarget variables). If these checks pass, the function updates the value of the liquidityRatioTarget variable and emits a LiquidityRatioTargetSet event.
This function can only be called by the contract owner.
The setLiquidityTokenReceiver function is a function for setting the address of the contract that should receive any new liquidity tokens that are minted. Liquidity tokens represent ownership of the liquidity pool and can be minted when new underlying tokens are added to the pool.
The function takes a single argument, liquidityTokenReceiver_, which is the address of the contract that should receive the new liquidity tokens. The function first checks that the provided address is not the zero address, is not the "dead" address (an address with all zeros), and is not the same as the current liquidity token receiver address. If these checks pass, the function updates the value of the liquidityTokenReceiver variable and emits a LiquidityTokenReceiverSet event.
This function can only be called by the contract owner.
The setDistributionTarget function is a function for setting the address of the contract that should receive a share of the fees collected by the X7DAOLiquidityHub contract. The function takes a single argument, target, which is the address of the contract that should receive the fees.
The function first checks that the provided address is not the zero address, is not the "dead" address (an address with all zeros), and is not the same as the current distribution target address. It also checks that the distributeTargetFrozen variable is not set (which indicates that the distribution target can be modified). If these checks pass, the function updates the value of the distributeTarget variable (which is a payable address) and emits a DistributeTargetSet event.
This function can only be called by the contract owner.
The setAuxiliaryTarget function is a function for setting the address of the contract that should receive a share of the fees collected by the X7DAOLiquidityHub contract. The function takes a single argument, target, which is the address of the contract that should receive the fees.
The function first checks that the provided address is not the zero address, is not the "dead" address (an address with all zeros), and is not the same as the current auxiliary target address. It also checks that the auxiliaryTargetFrozen variable is not set (which indicates that the auxiliary target can be modified). If these checks pass, the function updates the value of the auxiliaryTarget variable (which is a payable address) and emits an AuxiliaryTargetSet event.
This function can only be called by the contract owner.
The setTreasuryTarget function is a function for setting the address of the contract that should receive a share of the fees collected by the X7DAOLiquidityHub contract. The function takes a single argument, target, which is the address of the contract that should receive the fees.
The function first checks that the provided address is not the zero address, is not the dead address (an address with all zeros), and is not the same as the current treasury target address. It also checks that the treasuryTargetFrozen variable is not set (which indicates that the treasury target can be modified). If these checks pass, the function updates the value of the treasuryTarget variable (which is a payable address) and emits a TreasuryTargetSet event.
This function can only be called by the contract owner.
The freezeTreasuryTarget function is a function for freezing the address of the contract that receives a share of the fees collected by the X7DAOLiquidityHub contract. When the treasury target is frozen, it cannot be changed by calling the setTreasuryTarget function.
The function has no arguments. It simply sets the treasuryTargetFrozen variable to true and emits a TreasuryTargetFrozen event.
This function can only be called by the contract owner.
The freezeDistributeTarget function is a function for freezing the address of the contract that receives a share of the fees collected by the X7DAOLiquidityHub contract. When the distribution target is frozen, it cannot be changed by calling the setDistributionTarget function.
The function has no arguments. It simply sets the distributeTargetFrozen variable to true and emits a DistributeTargetFrozen event.
This function can only be called by the contract owner.
The freezeAuxiliaryTarget function is a function for freezing the address of the contract that receives a share of the fees collected by the X7DAOLiquidityHub contract. When the auxiliary target is frozen, it cannot be changed by calling the setAuxiliaryTarget function.
The function has no arguments. It simply sets the auxiliaryTargetFrozen variable to true and emits an AuxiliaryTargetFrozen event.
This function can only be called by the contract owner.
The freezeBalanceThreshold function is a function for freezing the balance threshold for the X7DAOLiquidityHub contract. The balance threshold is the minimum balance that must be reached in the contract before fees can be processed and distributed to the various accounts. When the balance threshold is frozen, it cannot be changed by calling the setBalanceThreshold function.
The function has no arguments. It simply sets the balanceThresholdFrozen variable to true and emits a BalanceThresholdFrozen event.
This function can only be called by the contract owner.
The processFees function is a function for processing and distributing fees collected by the X7DAOLiquidityHub contract. The function takes a single argument, tokenAddress, which is the address of the token contract that the fees were collected in.
The function begins by storing the contract's starting ETH balance in the startingETHBalance variable. It then calculates the number of tokens to swap for ETH by calling the balanceOf function of the token contract at tokenAddress, and subtracting the x7daoLiquidityBalance if the token is the x7dao token. If the number of tokens to swap is greater than zero, the function calls the swapTokensForEth function to swap the tokens for ETH.
After the tokens are swapped for ETH, the function calculates the total ETH balance for distribution by subtracting the starting ETH balance from the current contract balance. It then calculates the balances for the distribute, auxiliary, and treasury accounts by multiplying the distribution ETH balance by the corresponding share and dividing by 1000. It also calculates the remaining liquidity balance by subtracting the other balances from the total contract balance.
Finally, the function checks if any of the balances have reached or exceeded the balanceThreshold, and if so, calls the sendDistributeBalance, sendAuxiliaryBalance, `sendTreasuryBalance
The sendDistributeBalance function is a function for sending the balance in the distribute account of the X7DAOLiquidityHub contract to the distributeTarget address.
The function first checks if the distributeTarget address is not the zero address. If it is, the function returns without doing anything. If the distributeTarget address is not the zero address, the function calls the takeBalance function on the distributeTarget contract (which is assumed to be an instance of the IX7EcosystemSplitter interface).
Next, the function stores the current distributeBalance in the ethToSend variable and sets the distributeBalance to zero. It then calls the send function on the distributeTarget address, passing it the ethToSend value as the amount to send. If the send function call fails (i.e., returns false), the function sets the distributeBalance back to the ethToSend value.
This function is marked public so it can be called externally.
The sendTreasuryBalance function is a function for sending the balance in the treasury account of the X7DAOLiquidityHub contract to the treasuryTarget address.
The function first checks if the treasuryTarget address is not the zero address. If it is, the function returns without doing anything. If the treasuryTarget address is not the zero address, the function stores the current treasuryBalance in the ethToSend variable and sets the treasuryBalance to zero. It then calls the send function on the treasuryTarget address, passing it the ethToSend value as the amount to send. If the send function call fails (i.e., returns false), the function sets the treasuryBalance back to the ethToSend value.
This function is marked public so it can be called externally.
The sendAuxiliaryBalance function is a function for sending the balance in the auxiliary account of the X7DAOLiquidityHub contract to the auxiliaryTarget address.
The function first checks if the auxiliaryTarget address is not the zero address. If it is, the function returns without doing anything. If the auxiliaryTarget address is not the zero address, the function stores the current auxiliaryBalance in the ethToSend variable and sets the auxiliaryBalance to zero. It then calls the send function on the auxiliaryTarget address, passing it the ethToSend value as the amount to send. If the send function call fails (i.e., returns false), the function sets the auxiliaryBalance back to the ethToSend value.
This function is marked internal, which means it can only be called by other functions within the same contract or by derived contracts.
The buyBackAndAddLiquidity function is a function for buying back tokens and adding liquidity to the pool for the X7DAOLiquidityHub contract.
The function first checks the balance of the x7dao token on the off-ramp pair contract. If it is greater than the liquidityRatioTarget percentage of the circulating supply of the x7dao token, the function swaps all of the liquidityBalance for x7dao tokens using the swapEthForTokens function. If the balance of the x7dao token on the off-ramp pair contract is not greater than the liquidityRatioTarget percentage of the circulating supply of the x7dao token, the function does the following:
Stores the current liquidityBalance in the ethForSwap variable and sets the liquidityBalance to zero.
If the contract has any x7dao tokens, it adds liquidity to the pool using the addLiquidityETH function, passing it the balance of x7dao tokens that the contract holds and the remaining ethForSwap value. The ethForSwap value is updated to the difference between the starting ETH balance of the contract and its current ETH balance.
If there is still some ethForSwap left (i.e., the ethForSwap value is greater than zero), the function splits it in half and uses half of it to swap for x7dao tokens using the swapEthForTokens function and the other half to add liquidity to the pool using the addLiquidityETH function.
Finally, the function updates the x7daoLiquidityBalance variable to the current balance of x7dao tokens that the contract holds.
This function is marked internal, which means that it can only be called by other functions within the same contract. This means that it is not possible to call this function directly from another contract or from an external actor.
This function, addLiquidityETH, is used to add liquidity to the X7DAO liquidity hub contract.
This function takes two arguments: tokenAmount and ethAmount. The tokenAmount argument represents the amount of X7DAO tokens that should be added as liquidity, and the ethAmount argument represents the amount of Ether that should be added as liquidity.
The function first calls the approve function on the X7DAO contract, which allows the router contract to transfer the specified amount of X7DAO tokens on behalf of the liquidity hub contract. This is necessary because the addLiquidityETH function in the router contract will transfer the tokens from the liquidity hub contract to the router contract as part of the liquidity addition process.
Then, the function calls the addLiquidityETH function in the router contract, passing in the address of the X7DAO contract, the tokenAmount and ethAmount arguments, and some other parameters. This function will perform the actual liquidity addition process by creating a new liquidity pool in the exchange and adding the specified amount of X7DAO tokens and Ether as liquidity.
Finally, the function updates the x7daoLiquidityBalance variable to store the current balance of X7DAO tokens held by the liquidity hub contract. This variable is used to track the total amount of X7DAO tokens that have been added as liquidity to the exchange by the liquidity hub contract.
The function is called swapTokensForEth and it takes in two arguments: tokenAddress, which is the address of the token that we want to swap, and tokenAmount, which is the amount of tokens we want to swap.
The function first sets up an array path which contains the addresses of the token and WETH (wrapped ETH). Then it calls the approve function on the token contract to give the router contract permission to transfer tokenAmount of tokens on behalf of the contract.
Next, the function calls the swapExactTokensForETHSupportingFeeOnTransferTokens function on the router contract, passing in the amount of tokens we want to swap, a value of 0 for the minimum amount of ETH we want to receive, the path array, the contract's own address as the recipient, and the current block timestamp as the deadline. This function will swap the tokens for an equivalent amount of ETH.
The swapTokensForEth() function is used to swap a given amount of tokens for an equivalent amount of ETH. The function does this by calling the swapExactETHForTokensSupportingFeeOnTransferTokens function on the router contract, which is an instance of the V2 Router contract. This function takes four arguments:
slippage: The allowed slippage for the token to ETH exchange rate. A value of 0 means that the exchange rate must be exactly equal to the current market rate.
path: An array of addresses representing the token exchange path to use for the swap. In this case, the array contains the addresses of the WETH contract and the x7DAO token contract.
to: The address that will receive the tokens obtained from the swap. In this case, it is the contract's own address.
deadline: The timestamp after which the function call will be rejected. This is provided by the block.timestamp variable, which returns the current block's timestamp.
The function also includes a value keyword in its function call, which specifies the amount of ETH to send along with the function call. This is the amount of ETH that will be swapped for tokens.
Finally, the function does not return any value. Instead, the tokens obtained from the swap will be transferred to the contract's own address.
The rescueWETH() function allows the contract owner to withdraw any WETH tokens that may be stuck in the contract's balance. This can happen if, for example, the contract has mistakenly received WETH tokens through a function call that did not properly transfer ownership.
The function first gets the address of the WETH contract by calling the WETH() function on the router contract. Then it calls the withdraw() function on the WETH contract, passing in the balance of WETH tokens that the contract owns as an argument. This will transfer ownership of the WETH tokens back to the contract owner's address.
