Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {HelloBridgeStore} from "./HelloBridgeStore.sol";

/* -------------------------------------------------------------------------- */
/*                                   errors                                   */
/* -------------------------------------------------------------------------- */

error SignerNotWithdrawSigner();
error NoAmountToWithdraw();
error CannotBridgeToUnsupportedChain();
error Paused();
error NotPaused();
error ZeroAddress();
error InvalidSignature();
error InvalidFeePercentage();
error FeeWalletsNotSet();

///@notice The owner will always be a multisig wallet.

/* -------------------------------------------------------------------------- */
/*                                 HelloBridge                                */
/* -------------------------------------------------------------------------- */
/**
 * @title A cross-chain bridge for HelloToken
 * @author 0xSimon
 * @notice It is recommended to use the provided UI to bridge your tokens from chain A to chain B
 * @dev Assumptions:
 *     - On chains that this contract is deployed to (besides the mainnet), the entire supply of HelloToken will be minted and sent to this contract.
 */
contract HelloBridge is Ownable(msg.sender) {
    /* -------------------------------------------------------------------------- */
    /*                                   events                                   */
    /* -------------------------------------------------------------------------- */
    event Deposit(address indexed sender, uint256 amount, uint256 chainId);
    event Claim(
        address indexed sender,
        uint256 totalDepositedOnOtherChain,
        uint256 otherChainId
    );
    event SupportedChainChanged(uint256 chainID, bool isSupported);
    event SupportedChainsChanged(uint256[] chainIDs, bool isSupported);
    event WithdrawSigner1Changed(address signer);
    event WithdrawSigner2Changed(address signer);
    event PausedChanged(bool depositPaused, bool claimPaused);
    event BridgeStoreChanged(address store);
    event TreasuryWalletChanged(address newTreasuryWallet);
    event StakingPoolWalletChanged(address newStakingPoolWallet);
    event BurnWalletChanged(address newBurnWallet);
    event FeePercentageChanged(uint256 newFeePercentage);
    event FeeCollected(
        address indexed user,
        uint256 totalFeeAmount,
        uint256 burnAmount,
        uint256 stakingAmount,
        uint256 treasuryAmount
    );

    /* -------------------------------------------------------------------------- */
    /*                                  constants                                 */
    /* -------------------------------------------------------------------------- */
    /**
     * @notice The HelloToken contract
     */
    IERC20 public immutable HELLO_TOKEN;
    uint256 private constant MAX_FEE_PERCENTAGE = 500; // 5% max fee
    uint256 private constant BASIS_POINTS = 10000; // For fee calculations

    /* -------------------------------------------------------------------------- */
    /*                                   states                                   */
    /* -------------------------------------------------------------------------- */
    /**
     * @notice The signer providing signatures for claiming tokens on the destination chain
     */
    address public withdrawSigner1;
    address public withdrawSigner2;

    /**
     * @notice Storage contract for deposits and withdrawals numbers
     */
    HelloBridgeStore public store;

    /**
     * @notice A mapping to store which destination chains are supported
     */
    mapping(uint256 => bool) public supportedChains;

    bool public depositPaused;
    bool public claimPaused;

    // Fee related states
    address public treasuryWallet; // 1% goes here
    address public stakingPoolWallet; // 0.5% goes here
    address public burnWallet; // 0.5% goes here
    uint256 public feePercentage; // In basis points (e.g., 200 = 2%)
    address public adaptor;

    /**
     * @notice Deploys the contract and saves the HelloToken contract address
     * @dev `msg.sender` is assigned to the owner, pay attention if this contract is deployed via another contract
     * @param _helloToken The address of HelloToken
     */
    constructor(address _helloToken) {
        HELLO_TOKEN = IERC20(_helloToken);
        feePercentage = 200; // Default 2% fee
        burnWallet = 0x000000000000000000000000000000000000dEaD;
    }

    /* -------------------------------------------------------------------------- */
    /*                                Fee Functions                               */
    /* -------------------------------------------------------------------------- */

    /**
     * @notice Calculates the fee amount for a given total amount
     * @param amount The amount to calculate fee for
     * @return totalFee The total fee amount
     * @return burnAmount The amount to be sent to burn wallet (0.5%)
     * @return stakingAmount The amount to be sent to staking pool (0.5%)
     * @return treasuryAmount The amount to be sent to treasury (1%)
     */
    function calculateFees(
        uint256 amount
    )
        public
        view
        returns (
            uint256 totalFee,
            uint256 burnAmount,
            uint256 stakingAmount,
            uint256 treasuryAmount
        )
    {
        totalFee = (amount * feePercentage) / BASIS_POINTS;

        // Calculate individual fee components:
        // 0.5% to burn, 0.5% to staking, 1% to treasury
        burnAmount = (amount * 50) / BASIS_POINTS; // 0.5%
        stakingAmount = (amount * 50) / BASIS_POINTS; // 0.5%
        treasuryAmount = (amount * 100) / BASIS_POINTS; // 1%

        return (totalFee, burnAmount, stakingAmount, treasuryAmount);
    }

    /**
     * @notice Updates the treasury wallet address
     * @param newTreasuryWallet The new address to collect treasury fees (1%)
     */
    function setTreasuryWallet(address newTreasuryWallet) external onlyOwner {
        if (newTreasuryWallet == address(0)) _revert(ZeroAddress.selector);
        treasuryWallet = newTreasuryWallet;
        emit TreasuryWalletChanged(newTreasuryWallet);
    }

    /**
     * @notice Updates the staking pool wallet address
     * @param newStakingPoolWallet The new address to collect staking pool fees (0.5%)
     */
    function setStakingPoolWallet(
        address newStakingPoolWallet
    ) external onlyOwner {
        if (newStakingPoolWallet == address(0)) _revert(ZeroAddress.selector);
        stakingPoolWallet = newStakingPoolWallet;
        emit StakingPoolWalletChanged(newStakingPoolWallet);
    }

    /**
     * @notice Updates the burn wallet address
     * @param newBurnWallet The new address to send tokens for burning (0.5%)
     */
    function setBurnWallet(address newBurnWallet) external onlyOwner {
        if (newBurnWallet == address(0)) _revert(ZeroAddress.selector);
        burnWallet = newBurnWallet;
        emit BurnWalletChanged(newBurnWallet);
    }
    function setAdaptorContract(address newAdaptor) external onlyOwner {
        if (newAdaptor == address(0)) _revert(ZeroAddress.selector);
        adaptor = newAdaptor;
    }

    /* -------------------------------------------------------------------------- */
    /*                              ECDSA Functions                              */
    /* -------------------------------------------------------------------------- */

    /**
     * @dev Recover signer address from a message by using their signature
     * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
     * @param signature bytes signature, the signature is generated using web3.eth.sign()
     */
    function recoverSigner(
        bytes32 hash,
        bytes memory signature
    ) internal pure returns (address) {
        if (signature.length != 65) {
            revert InvalidSignature();
        }

        bytes32 r;
        bytes32 s;
        uint8 v;

        assembly {
            r := mload(add(signature, 32))
            s := mload(add(signature, 64))
            v := byte(0, mload(add(signature, 96)))
        }

        if (
            uint256(s) >
            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
        ) {
            revert InvalidSignature();
        }

        if (v != 27 && v != 28) {
            revert InvalidSignature();
        }

        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            revert InvalidSignature();
        }

        return signer;
    }

    /**
     * @dev Returns the hash of a message that can be signed by external wallets.
     * @param message bytes32 message to be signed
     * @return bytes32 The Ethereum signed message hash
     */
    function hashEthSignedMessage(
        bytes32 message
    ) internal pure returns (bytes32) {
        return
            keccak256(
                abi.encodePacked("\x19Ethereum Signed Message:\n32", message)
            );
    }

    /* -------------------------------------------------------------------------- */
    /*                                  external                                  */
    /* -------------------------------------------------------------------------- */
    /**
     * @notice Bridge HelloToken to another chain. HelloToken will be transferred to this contract.
     * @notice Ensure approvals for HelloToken has been set and the destination chain is supported.
     * @param amount Amount of HelloToken to bridge to another chain
     * @param chainId The chain ID of the destination chain
     * @dev Reverts if the destination chain is not supported
     */
    function sendToChain(uint256 amount, uint256 chainId) external {
        if (depositPaused) _revert(Paused.selector);
        if (!supportedChains[chainId])
            _revert(CannotBridgeToUnsupportedChain.selector);

        // Check that all fee wallets are set
        if (
            treasuryWallet == address(0) ||
            stakingPoolWallet == address(0) ||
            burnWallet == address(0)
        ) _revert(FeeWalletsNotSet.selector);

        // Calculate fee distribution
        (
            uint256 totalFee,
            uint256 burnAmount,
            uint256 stakingAmount,
            uint256 treasuryAmount
        ) = calculateFees(amount);
        uint256 netAmount = amount - totalFee;

        // Update state with net amount
        uint256 _currentDeposit = store.totalCrossChainDeposits(
            msg.sender,
            chainId
        );
        store.setTotalCrossChainDeposits(
            msg.sender,
            chainId,
            _currentDeposit + netAmount
        );

        // Transfer tokens - net amount to bridge
        HELLO_TOKEN.transferFrom(msg.sender, address(this), netAmount);

        // Transfer fees to respective destinations
        HELLO_TOKEN.transferFrom(msg.sender, burnWallet, burnAmount);
        HELLO_TOKEN.transferFrom(msg.sender, stakingPoolWallet, stakingAmount);
        HELLO_TOKEN.transferFrom(msg.sender, treasuryWallet, treasuryAmount);

        emit Deposit(msg.sender, netAmount, chainId);
        emit FeeCollected(
            msg.sender,
            totalFee,
            burnAmount,
            stakingAmount,
            treasuryAmount
        );
    }

    /**
     * @notice Claims tokens deposited in the source chain. Two signatures are required.
     * @notice HelloToken will be transferred from this account to the caller.
     * @param totalDepositedOnOtherChain The total amount you have deposited in the source chain
     * @param otherChainId The chain ID of the source chain
     * @param signature1 The first signature for verification
     * @param signature2 The second signature for verification
     * @dev Reverts if there's no amount to claim.
     * @dev Reverts if either signature is invalid
     */
    function claimFromChain(
        uint256 totalDepositedOnOtherChain,
        uint256 otherChainId,
        bytes calldata signature1,
        bytes calldata signature2
    ) external {
        if (claimPaused) _revert(Paused.selector);

        uint256 amountToWithdraw = totalDepositedOnOtherChain -
            store.totalCrossChainWithdrawals(msg.sender, otherChainId);

        if (amountToWithdraw == 0) _revert(NoAmountToWithdraw.selector);

        bytes32 hash = keccak256(
            abi.encodePacked(
                msg.sender,
                totalDepositedOnOtherChain,
                otherChainId,
                block.chainid,
                address(this)
            )
        );

        bytes32 ethSignedHash = hashEthSignedMessage(hash);

        if (recoverSigner(ethSignedHash, signature1) != withdrawSigner1) {
            _revert(SignerNotWithdrawSigner.selector);
        }

        if (recoverSigner(ethSignedHash, signature2) != withdrawSigner2) {
            _revert(SignerNotWithdrawSigner.selector);
        }

        uint256 netAmount = amountToWithdraw;

        store.setTotalCrossChainWithdrawals(
            msg.sender,
            otherChainId,
            totalDepositedOnOtherChain
        );

        // Transfer tokens to user
        HELLO_TOKEN.transfer(msg.sender, netAmount);

        emit Claim(msg.sender, totalDepositedOnOtherChain, otherChainId);
    }

    function claimFromChainSolana(
        uint256 totalDepositedOnOtherChain,
        uint256 otherChainId,
        uint256 totalUserAmountWithdrawable,
        bytes calldata signature1,
        bytes calldata signature2
    ) external {
        require(msg.sender == adaptor, "Only adaptor can call");
        if (claimPaused) _revert(Paused.selector);

        uint256 amountToWithdraw = totalDepositedOnOtherChain -
            store.totalCrossChainWithdrawals(msg.sender, otherChainId);

        if (amountToWithdraw == 0) _revert(NoAmountToWithdraw.selector);

        bytes32 hash = keccak256(
            abi.encodePacked(
                msg.sender,
                totalDepositedOnOtherChain,
                otherChainId,
                block.chainid,
                address(this)
            )
        );

        bytes32 ethSignedHash = hashEthSignedMessage(hash);

        if (recoverSigner(ethSignedHash, signature1) != withdrawSigner1) {
            _revert(SignerNotWithdrawSigner.selector);
        }

        if (recoverSigner(ethSignedHash, signature2) != withdrawSigner2) {
            _revert(SignerNotWithdrawSigner.selector);
        }

        uint256 netAmount = totalUserAmountWithdrawable;

        store.setTotalCrossChainWithdrawals(
            msg.sender,
            otherChainId,
            totalDepositedOnOtherChain
        );

        // Transfer tokens to user
        HELLO_TOKEN.transfer(msg.sender, netAmount);

        emit Claim(msg.sender, totalDepositedOnOtherChain, otherChainId);
    }

    /* -------------------------------------------------------------------------- */
    /*                                   owners                                   */
    /* -------------------------------------------------------------------------- */
    /**
     * @notice Owner only - Updates the address of the withdrawal signer
     * @param _withdrawSigner Address of the withdrawal signer
     */
    function setWithdrawSigner(address _withdrawSigner) external onlyOwner {
        if (_withdrawSigner == address(0)) {
            _revert(ZeroAddress.selector);
        }
        withdrawSigner1 = _withdrawSigner;
        emit WithdrawSigner1Changed(_withdrawSigner);
    }

    function setWithdrawSigner2(address _withdrawSigner2) external onlyOwner {
        if (_withdrawSigner2 == address(0)) {
            _revert(ZeroAddress.selector);
        }
        withdrawSigner2 = _withdrawSigner2;
        emit WithdrawSigner2Changed(_withdrawSigner2);
    }

    /**
     * @notice Owner only - Updates a supported destination chain
     * @param chainId Chain ID of a destination chain
     * @param isSupported Whether the destination chain is supported
     */
    function setSupportedChain(
        uint256 chainId,
        bool isSupported
    ) external onlyOwner {
        _setSupportedChain(chainId, isSupported);
        emit SupportedChainChanged(chainId, isSupported);
    }

    /**
     * @notice Owner only - Batch update supported destination chains
     * @param chainIds Chain IDs of the destination chains
     * @param isSupported Whether the destination chains are supported
     */
    function setSupportedChains(
        uint256[] calldata chainIds,
        bool isSupported
    ) external onlyOwner {
        for (uint256 i; i < chainIds.length; ) {
            _setSupportedChain(chainIds[i], isSupported);
            unchecked {
                ++i;
            }
        }
        emit SupportedChainsChanged(chainIds, isSupported);
    }

    /**
     * @notice Pause / unpause deposit & claim
     * @param depositPaused_ Whether to pause deposit
     * @param claimPaused_ Whether to pause claim
     */
    function setPaused(
        bool depositPaused_,
        bool claimPaused_
    ) external onlyOwner {
        depositPaused = depositPaused_;
        claimPaused = claimPaused_;
        emit PausedChanged(depositPaused_, claimPaused_);
    }

    function setBridgeStore(address a_) external onlyOwner {
        if (a_ == address(0)) {
            _revert(ZeroAddress.selector);
        }
        store = HelloBridgeStore(a_);
        emit BridgeStoreChanged(a_);
    }

    /**
     * @notice Migrates the bridge contract to another. Tokens in this contract will be transferred to the new contract.
     * @dev The new bridge contract should use the data stored in `store`.
     * @param bridgeAddress Address of the new contract
     */
    function migrateBridge(address bridgeAddress) external onlyOwner {
        if (bridgeAddress == address(0)) {
            _revert(ZeroAddress.selector);
        }
        if (!depositPaused || !claimPaused) {
            _revert(NotPaused.selector);
        }
        HELLO_TOKEN.transfer(
            bridgeAddress,
            HELLO_TOKEN.balanceOf(address(this))
        );
    }

    /* -------------------------------------------------------------------------- */
    /*                                  internal                                  */
    /* -------------------------------------------------------------------------- */
    function _setSupportedChain(uint256 chainId, bool isSupported) internal {
        supportedChains[chainId] = isSupported;
    }

    function _revert(bytes4 selector) internal pure {
        assembly {
            mstore(0x0, selector)
            revert(0x0, 0x04)
        }
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;

import {HelloBridgeStore} from "./HelloBridgeStore.sol";
import {HelloBridge} from "./HelloBridge.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title Hello Labs Bridge Adapter for Solana
 * @notice This contract is the adapter for the Solana chain
 * @notice Owner should always be a multisig wallet
 * @dev It interacts with the bridge contract to send and receive tokens from the Solana chain
 */
contract HelloBridgeSolanaAdapter is Ownable(msg.sender) {
    error DepositPaused();
    error WithdrawPaused();
    error InvalidSolanaSignature1();
    error InvalidSolanaSignature2();
    error InvalidSignature();
    error FeeWalletsNotSet();
    error InvalidFeePercentage();
    error InsufficientAdapterBalance(); // New error for Solution 2

    // EIP712 Domain
    bytes32 private immutable DOMAIN_SEPARATOR;

    // EIP712 TypeHash
    bytes32 private constant EIP712_DOMAIN_TYPEHASH =
        keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );

    HelloBridgeStore public $store;
    HelloBridge public $bridge;
    IERC20 public immutable HELLO_TOKEN;

    // Reference to the old Solana adapter contract
    HelloBridgeSolanaAdapter public constant oldSolanaAdapter =
        HelloBridgeSolanaAdapter(0xdB3b2f0ffe05d35953D727A82F7a41f78e5F3EA1);

    //cast keccak "solana"
    uint256 public constant SOLANA_CHAIN_ID =
        0x6eef29ebb03aa2144a1a6b6212ce74f504a34db799b8161a21140017e80d3d8a;
    bytes32 public constant CLAIM_FROM_SOLANA_TYPEHASH =
        keccak256(
            "ClaimFromSolana(address ethAddress,bytes32 solanaAddress,uint256 totalUserAmountWithdrawable)"
        );

    mapping(address => mapping(bytes32 => uint256))
        public amountDepositedOnSolana;
    mapping(address => mapping(bytes32 => uint256))
        public amountWithdrawnFromSolana;

    bool public depositPaused;
    bool public withdrawPaused;

    // Fee related states
    address public treasuryWallet; // 1% goes here
    address public stakingPoolWallet; // 0.5% goes here
    address public burnWallet; // 0.5% goes here
    uint256 public constant feePercentage = 200; // In basis points (e.g., 200 = 2%)
    uint256 private constant MAX_FEE_PERCENTAGE = 500; // 5% max fee
    uint256 private constant BASIS_POINTS = 10000; // For fee calculations

    event Deposit(address indexed user, uint256 amount, bytes32 solanaAddress);
    event Withdraw(address indexed user, uint256 amount, bytes32 solanaAddress);
    event PauseChanged(bool depositChanged, bool withdrawChanged);
    event BridgeChanged(address newBridge);
    event StoreChanged(address newStore);
    event TreasuryWalletChanged(address newTreasuryWallet);
    event StakingPoolWalletChanged(address newStakingPoolWallet);
    event BurnWalletChanged(address newBurnWallet);
    event FeeCollected(
        address indexed user,
        uint256 totalFeeAmount,
        uint256 burnAmount,
        uint256 stakingAmount,
        uint256 treasuryAmount
    );

    event BridgeClaimSkipped(
        uint256 totalCrossChainWithdrawals,
        uint256 totalAmountDepositedToSolanaAdapter
    ); // New event for Solution 2

    constructor(address _store, address _bridge, address _helloToken) {
        $store = HelloBridgeStore(_store);
        $bridge = HelloBridge(_bridge);
        HELLO_TOKEN = IERC20(_helloToken);

        // Initialize domain separator
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256("HelloBridgeSolanaAdapter"),
                keccak256("1.0"),
                block.chainid,
                address(this)
            )
        );

        //Set the allownace to the bridge to type(uint256).max
        //To avoid extra sstores and gas fees in the deposit function
        HELLO_TOKEN.approve(address($bridge), type(uint256).max);
    }

    /* -------------------------------------------------------------------------- */
    /*                                Fee Functions                               */
    /* -------------------------------------------------------------------------- */

    /**
     * @notice Calculates the fee amount for a given total amount
     * @param amount The amount to calculate fee for
     * @return totalFee The total fee amount
     * @return burnAmount The amount to be sent to burn wallet (0.5%)
     * @return stakingAmount The amount to be sent to staking pool (0.5%)
     * @return treasuryAmount The amount to be sent to treasury (1%)
     */
    function calculateFees(
        uint256 amount
    )
        public
        view
        returns (
            uint256 totalFee,
            uint256 burnAmount,
            uint256 stakingAmount,
            uint256 treasuryAmount
        )
    {
        totalFee = (amount * feePercentage) / BASIS_POINTS;

        // Calculate individual fee components:
        // 0.5% to burn, 0.5% to staking, 1% to treasury
        burnAmount = (amount * 50) / BASIS_POINTS; // 0.5%
        stakingAmount = (amount * 50) / BASIS_POINTS; // 0.5%
        treasuryAmount = (amount * 100) / BASIS_POINTS; // 1%

        return (totalFee, burnAmount, stakingAmount, treasuryAmount);
    }

    /**
     * @notice Updates the treasury wallet address
     * @param newTreasuryWallet The new address to collect treasury fees (1%)
     */
    function setTreasuryWallet(address newTreasuryWallet) external onlyOwner {
        if (newTreasuryWallet == address(0)) revert ZeroAddress();
        treasuryWallet = newTreasuryWallet;
        emit TreasuryWalletChanged(newTreasuryWallet);
    }

    /**
     * @notice Updates the staking pool wallet address
     * @param newStakingPoolWallet The new address to collect staking pool fees (0.5%)
     */
    function setStakingPoolWallet(
        address newStakingPoolWallet
    ) external onlyOwner {
        if (newStakingPoolWallet == address(0)) revert ZeroAddress();
        stakingPoolWallet = newStakingPoolWallet;
        emit StakingPoolWalletChanged(newStakingPoolWallet);
    }

    /**
     * @notice Updates the burn wallet address
     * @param newBurnWallet The new address to send tokens for burning (0.5%)
     */
    function setBurnWallet(address newBurnWallet) external onlyOwner {
        if (newBurnWallet == address(0)) revert ZeroAddress();
        burnWallet = newBurnWallet;
        emit BurnWalletChanged(newBurnWallet);
    }

    /**
     * @notice Get the total withdrawn amount including both old and current contracts
     * @param ethAddress The Ethereum address of the user
     * @param solanaAddress The Solana address of the user
     * @return total Total withdrawn amount across both contracts
     */
    function getTotalWithdrawnAmount(
        address ethAddress,
        bytes32 solanaAddress
    ) public view returns (uint256) {
        uint256 currentContractWithdrawn = amountWithdrawnFromSolana[
            ethAddress
        ][solanaAddress];
        uint256 oldContractWithdrawn = address(oldSolanaAdapter) != address(0)
            ? oldSolanaAdapter.amountWithdrawnFromSolana(
                ethAddress,
                solanaAddress
            )
            : 0;

        return currentContractWithdrawn + oldContractWithdrawn;
    }

    function depositOnSolana(uint256 amount, bytes32 solanaAddress) external {
        if (depositPaused) {
            revert DepositPaused();
        }

        // Transfer tokens - net amount to this contract
        HELLO_TOKEN.transferFrom(msg.sender, address(this), amount);

        // Send to Solana chain
        $bridge.sendToChain(amount, SOLANA_CHAIN_ID);

        uint256 totalFee = (amount * feePercentage) / BASIS_POINTS;

        // Update deposits tracking
        amountDepositedOnSolana[msg.sender][solanaAddress] += amount - totalFee;

        emit Deposit(msg.sender, amount - totalFee, solanaAddress);
    }

    /**
     * @notice Withdraw from Solana
     * @param ethAddress The address of the user on Ethereum
     * @param solanaAddress The address of the user on Solana
     * @param totalAmountDepositedToSolanaAdapter The total amount deposited on the Solana Bridge for this chain
     * @param totalUserAmountWithdrawable The total amount that the user can withdraw
     * @param bridgeSig1 The signature to use in the claim from the bridge
     * @param bridgeSig2 The signature to use in the claim from the bridge
     * @param adapterSig1 The signature to check in the adapter
     * @param adapterSig2 The signature to check in the adapter
     */
    function withdrawFromSolana(
        address ethAddress,
        bytes32 solanaAddress,
        uint256 totalAmountDepositedToSolanaAdapter,
        uint256 totalUserAmountWithdrawable,
        bytes calldata bridgeSig1,
        bytes calldata bridgeSig2,
        bytes calldata adapterSig1,
        bytes calldata adapterSig2
    ) external {
        if (withdrawPaused) {
            revert WithdrawPaused();
        }

        // Check that all fee wallets are set
        if (
            treasuryWallet == address(0) ||
            stakingPoolWallet == address(0) ||
            burnWallet == address(0)
        ) revert FeeWalletsNotSet();

        HelloBridge _bridge = $bridge;
        HelloBridgeStore _store = $store;

        // Calculate total withdrawn amount from both old and current contracts
        uint256 totalWithdrawn = getTotalWithdrawnAmount(
            ethAddress,
            solanaAddress
        );
        uint256 amountToWithdraw = totalUserAmountWithdrawable - totalWithdrawn;

        // Exit early if nothing to withdraw
        if (amountToWithdraw == 0) return;

        _checkAdapterSignatures(
            _bridge,
            ethAddress,
            solanaAddress,
            totalUserAmountWithdrawable,
            adapterSig1,
            adapterSig2
        );

        bool bridgeClaimPerformed = _claimFromBridge(
            _bridge,
            _store,
            totalAmountDepositedToSolanaAdapter,
            amountToWithdraw,
            bridgeSig1,
            bridgeSig2
        );

        // SOLUTION 2: Add check for sufficient adapter balance before proceeding
        if (!bridgeClaimPerformed) {
            // Calculate total amount needed (including fees)
            (
                uint256 totalFee,
                uint256 burnAmount,
                uint256 stakingAmount,
                uint256 treasuryAmount
            ) = calculateFees(amountToWithdraw);
            uint256 totalTokensNeeded = amountToWithdraw + totalFee;

            // Check if adapter has sufficient balance
            if (HELLO_TOKEN.balanceOf(address(this)) < totalTokensNeeded) {
                revert InsufficientAdapterBalance();
            }
        }

        _handleWithdraw(ethAddress, solanaAddress, totalUserAmountWithdrawable);
    }

    /// @dev anyone can call this function once the allowance has run low
    /// @dev this contract should never hold tokens, so this function is safe
    function approveBridge() external {
        HELLO_TOKEN.approve(address($bridge), type(uint256).max);
    }

    function setWithdrawPaused(bool _paused) external onlyOwner {
        withdrawPaused = _paused;
        emit PauseChanged(false, _paused);
    }

    function setDepositPaused(bool _paused) external onlyOwner {
        depositPaused = _paused;
        emit PauseChanged(true, _paused);
    }

    function setBridge(address _bridge) external onlyOwner {
        $bridge = HelloBridge(_bridge);
        emit BridgeChanged(_bridge);
    }

    function setStore(address _store) external onlyOwner {
        $store = HelloBridgeStore(_store);
        emit StoreChanged(_store);
    }

    // New function for Solution 2: Get adapter's available balance
    function getAvailableBalance() external view returns (uint256) {
        return HELLO_TOKEN.balanceOf(address(this));
    }

    function getClaimFromSolanaDigest(
        address ethAddress,
        bytes32 solanaAddress,
        uint256 totalUserAmountWithdrawable
    ) public view returns (bytes32) {
        bytes32 structHash = keccak256(
            abi.encode(
                CLAIM_FROM_SOLANA_TYPEHASH,
                ethAddress,
                solanaAddress,
                totalUserAmountWithdrawable
            )
        );
        return
            keccak256(
                abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, structHash)
            );
    }

    //------------------ Internal functions ------------------//

    function _handleWithdraw(
        address ethAddress,
        bytes32 solanaAddress,
        uint256 totalAmountWithdrawable
    ) internal {
        // Calculate total withdrawn amount from both old and current contracts
        uint256 totalWithdrawn = getTotalWithdrawnAmount(
            ethAddress,
            solanaAddress
        );
        uint256 amountToWithdraw = totalAmountWithdrawable - totalWithdrawn;

        // Calculate fees on the amount to withdraw
        (
            uint256 totalFee,
            uint256 burnAmount,
            uint256 stakingAmount,
            uint256 treasuryAmount
        ) = calculateFees(amountToWithdraw);
        uint256 netAmount = amountToWithdraw - totalFee;

        // Update withdrawal tracking - assign only the difference to the current contract
        // We deduct old contract withdrawal amount from totalAmountWithdrawable
        uint256 oldContractWithdrawn = address(oldSolanaAdapter) != address(0)
            ? oldSolanaAdapter.amountWithdrawnFromSolana(
                ethAddress,
                solanaAddress
            )
            : 0;

        amountWithdrawnFromSolana[ethAddress][solanaAddress] =
            totalAmountWithdrawable -
            oldContractWithdrawn;

        // Transfer net amount to user
        HELLO_TOKEN.transfer(ethAddress, netAmount);

        // Transfer fees to respective destinations
        HELLO_TOKEN.transfer(burnWallet, burnAmount);
        HELLO_TOKEN.transfer(stakingPoolWallet, stakingAmount);
        HELLO_TOKEN.transfer(treasuryWallet, treasuryAmount);

        emit Withdraw(ethAddress, netAmount, solanaAddress);
        emit FeeCollected(
            ethAddress,
            totalFee,
            burnAmount,
            stakingAmount,
            treasuryAmount
        );
    }

    /**
     * @dev Attempt to claim tokens from the bridge
     * @return bridgeClaimPerformed Whether the tokens were claimed from the bridge
     */
    function _claimFromBridge(
        HelloBridge _bridge,
        HelloBridgeStore _store,
        uint256 totalAmountDepositedToSolanaAdapter,
        uint256 totalUserAmountWithdrawable,
        bytes calldata bridgeSig1,
        bytes calldata bridgeSig2
    ) internal returns (bool bridgeClaimPerformed) {
        uint256 currentWithdrawals = _store.totalCrossChainWithdrawals(
            address(this),
            SOLANA_CHAIN_ID
        );

        //If a transaction has front-run the claim, the bridge will revert
        //So we only claim if the total amount deposited (approved by signers) is less than the total amount withdrawn
        if (currentWithdrawals < totalAmountDepositedToSolanaAdapter) {
            _bridge.claimFromChainSolana(
                totalAmountDepositedToSolanaAdapter, // totalDepositedOnOtherChain
                SOLANA_CHAIN_ID, // otherChainId
                totalUserAmountWithdrawable,
                bridgeSig1, // signature1
                bridgeSig2 // signature2
            );
            return true;
        } else {
            // SOLUTION 2: Log when bridge claim is skipped
            emit BridgeClaimSkipped(
                currentWithdrawals,
                totalAmountDepositedToSolanaAdapter
            );
            return false;
        }
    }

    function _checkAdapterSignatures(
        HelloBridge _bridge,
        address ethAddress,
        bytes32 solanaAddress,
        uint256 totalUserAmountWithdrawable,
        bytes calldata adapterSig1,
        bytes calldata adapterSig2
    ) internal view {
        bytes32 digest = getClaimFromSolanaDigest(
            ethAddress,
            solanaAddress,
            totalUserAmountWithdrawable
        );

        if (
            !_isValidSignature(_bridge.withdrawSigner1(), digest, adapterSig1)
        ) {
            revert InvalidSolanaSignature1();
        }
        if (
            !_isValidSignature(_bridge.withdrawSigner2(), digest, adapterSig2)
        ) {
            revert InvalidSolanaSignature2();
        }
    }

    function withdrawTokens(uint256 _amount) external onlyOwner {
        HELLO_TOKEN.transfer(msg.sender, _amount);
    }

    /**
     * @dev Checks if a signature is valid for a signer and digest
     * @param signer The address that should have signed the digest
     * @param digest The digest that was signed
     * @param signature The signature to check
     */
    function _isValidSignature(
        address signer,
        bytes32 digest,
        bytes memory signature
    ) internal pure returns (bool) {
        if (signature.length != 65) {
            return false;
        }

        bytes32 r;
        bytes32 s;
        uint8 v;

        assembly {
            r := mload(add(signature, 32))
            s := mload(add(signature, 64))
            v := byte(0, mload(add(signature, 96)))
        }

        if (
            uint256(s) >
            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
        ) {
            return false;
        }

        if (v != 27 && v != 28) {
            return false;
        }

        address recoveredSigner = ecrecover(digest, v, r, s);
        if (recoveredSigner == address(0)) {
            return false;
        }

        return recoveredSigner == signer;
    }

    // Custom error for zero address checks
    error ZeroAddress();
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

///@notice The contract is a storage contract for the bridge contract.
///@notice The owner will always be a multisig wallet.

/* -------------------------------------------------------------------------- */
/*                                   errors                                   */
/* -------------------------------------------------------------------------- */
error SignerNotWithdrawSigner();
error NoAmountToWithdraw();
error CannotBridgeToUnsupportedChain();
error Paused();
error NotPaused();
error ZeroAddress();

contract HelloBridgeStore is Ownable(msg.sender) {
    /* -------------------------------------------------------------------------- */
    /*                                   errors                                   */
    /* -------------------------------------------------------------------------- */
    error ErrUnauthorized();
    error ErrZeroAddress();

    /* -------------------------------------------------------------------------- */
    /*                                   events                                   */
    /* -------------------------------------------------------------------------- */
    event BridgeContractChanged(address bridgeContract);

    /* -------------------------------------------------------------------------- */
    /*                                   states                                   */
    /* -------------------------------------------------------------------------- */
    /**
     * @notice A mapping that stores how much HelloToken a user has deposited to bridge to a destination chain
     * @dev Maps from userAddress -> chainID -> amount
     */
    mapping(address => mapping(uint256 => uint256))
        public totalCrossChainDeposits;

    /**
     * @notice A mapping that stores how much HelloToken a user has withdrawn from a destination chain
     * @dev Maps from userAddress -> chainID -> amount
     */
    mapping(address => mapping(uint256 => uint256))
        public totalCrossChainWithdrawals;

    /**
     * @notice The bridge contract associated with this storage contract.
     * This is the only contract authorized to update `totalCrossChainDeposits` & `totalCrossChainWithdrawals`
     */
    address public bridgeContract;

    /* -------------------------------------------------------------------------- */
    /*                                    owner                                   */
    /* -------------------------------------------------------------------------- */
    /**
     * @notice Updates the bridge contract associated with this storage contract
     */
    function setBridgeContract(address b_) external onlyOwner {
        if (b_ == address(0)) {
            revert ErrZeroAddress();
        }

        bridgeContract = b_;

        emit BridgeContractChanged(b_);
    }

    /* -------------------------------------------------------------------------- */
    /*                                  external                                  */
    /* -------------------------------------------------------------------------- */
    /**
     * @notice Updates totalCrossChainDeposits of a user to a destination chain
     * @param address_ The address to update
     * @param chainID_ The destination chainID of the deposit
     * @param amount_ The amount of token deposited
     */
    function setTotalCrossChainDeposits(
        address address_,
        uint256 chainID_,
        uint256 amount_
    ) external {
        if (msg.sender != bridgeContract) {
            revert ErrUnauthorized();
        }

        totalCrossChainDeposits[address_][chainID_] = amount_;
    }

    /**
     * @notice Updates totalCrossChainWithdrawals of a user from a source chain
     * @param address_ The address to update
     * @param chainID_ The source chainID of the withdrawal
     * @param amount_ The amount of token withdrawn
     */
    function setTotalCrossChainWithdrawals(
        address address_,
        uint256 chainID_,
        uint256 amount_
    ) external {
        if (msg.sender != bridgeContract) {
            revert ErrUnauthorized();
        }

        totalCrossChainWithdrawals[address_][chainID_] = amount_;
    }
}