Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "../interfaces/IWormholeRelayer.sol";
import "../interfaces/ITokenBridge.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/**
 * @title DepositBridge
 * @notice Bridge ZEUS from Ethereum to Base in 1 TX with Wormhole Auto-Relay
 * @dev Uses separate TokenBridge.transferTokens() + WormholeRelayer.sendPayloadToEvm()
 *      because transferTokensWithPayload() doesn't support automatic relay
 */
contract DepositBridge is ReentrancyGuard {
    IERC20 public immutable zeusToken;
    ITokenBridge public immutable tokenBridge;
    IWormholeRelayer public immutable wormholeRelayer;

    uint16 public constant BASE_CHAIN_ID = 30;  // Wormhole chain ID for Base
    uint16 public constant ETHEREUM_CHAIN_ID = 2;  // Wormhole chain ID for Ethereum
    uint256 public constant GAS_LIMIT = 250_000;  // Gas for receiving on Base

    address public walletFactoryOnBase;  // WalletFactory contract address on Base
    bytes32 public userWalletBytecodeHash;  // Hash of UserWallet bytecode for CREATE2 computation
    address public owner;

    bool public paused = false;

    event DepositInitiated(
        address indexed user,
        string twitterHandle,
        address indexed recipientWallet,
        uint256 amount,
        uint64 tokenSequence,
        uint64 messageSequence
    );
    event Paused(address indexed by);
    event Unpaused(address indexed by);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor(
        address _zeusToken,
        address _wormholeRelayer,
        address _tokenBridge,
        address _walletFactoryOnBase,
        bytes32 _userWalletBytecodeHash
    ) {
        require(_zeusToken != address(0), "Invalid token");
        require(_wormholeRelayer != address(0), "Invalid relayer");
        require(_tokenBridge != address(0), "Invalid bridge");
        require(_walletFactoryOnBase != address(0), "Invalid factory");
        require(_userWalletBytecodeHash != bytes32(0), "Invalid bytecode hash");

        zeusToken = IERC20(_zeusToken);
        wormholeRelayer = IWormholeRelayer(_wormholeRelayer);
        tokenBridge = ITokenBridge(_tokenBridge);
        walletFactoryOnBase = _walletFactoryOnBase;
        userWalletBytecodeHash = _userWalletBytecodeHash;
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    modifier whenNotPaused() {
        require(!paused, "Contract paused");
        _;
    }

    /**
     * @notice Emergency pause
     */
    function pause() external onlyOwner {
        paused = true;
        emit Paused(msg.sender);
    }

    function unpause() external onlyOwner {
        paused = false;
        emit Unpaused(msg.sender);
    }

    /**
     * @notice Compute deterministic UserWallet address on Base (same as WalletFactory.computeAddress)
     * @param twitterHandle Twitter handle (without @)
     * @return Predicted UserWallet address on Base
     */
    function computeUserWalletAddress(string memory twitterHandle)
        public
        view
        returns (address)
    {
        // V3: Add "_v3" suffix to match WalletFactory V3 on Base
        bytes32 salt = keccak256(abi.encodePacked(twitterHandle, "_v3"));

        bytes32 hash = keccak256(
            abi.encodePacked(
                bytes1(0xff),
                walletFactoryOnBase,
                salt,
                userWalletBytecodeHash
            )
        );

        return address(uint160(uint256(hash)));
    }

    /**
     * @notice Quote cost for bridge (only WormholeRelayer fee, TokenBridge is free)
     */
    function quoteCrossChainDeposit() public view returns (uint256 cost) {
        (uint256 deliveryCost, ) = wormholeRelayer.quoteEVMDeliveryPrice(
            BASE_CHAIN_ID,
            0,
            GAS_LIMIT
        );
        return deliveryCost;
    }

    /**
     * @notice Deposit and bridge to Base in 1 TX
     * @param amount Amount of ZEUS tokens
     * @param twitterHandle Twitter handle of recipient (without @)
     * @dev Computes UserWallet address deterministically and sends tokens directly
     *      UserWallet doesn't need to be deployed yet - tokens will arrive when it's deployed
     */
    function depositAndBridge(
        uint256 amount,
        string memory twitterHandle
    ) external payable nonReentrant whenNotPaused {
        require(amount > 0, "Amount must be > 0");
        require(bytes(twitterHandle).length > 0, "Empty twitter handle");

        // Compute deterministic UserWallet address (may not be deployed yet)
        address recipientWallet = computeUserWalletAddress(twitterHandle);

        uint256 cost = quoteCrossChainDeposit();
        require(msg.value >= cost, "Insufficient fee");

        // Transfer ZEUS from user
        uint256 balanceBefore = zeusToken.balanceOf(address(this));
        require(zeusToken.transferFrom(msg.sender, address(this), amount), "Transfer failed");

        // Verify actual amount received (handles fee-on-transfer tokens)
        uint256 balanceAfter = zeusToken.balanceOf(address(this));
        uint256 actualAmount = balanceAfter - balanceBefore;
        require(actualAmount >= amount, "Transfer amount mismatch");

        // 1. Send tokens via TokenBridge directly to UserWallet on Base
        // Note: Wallet doesn't need to be deployed yet - tokens will arrive when it's deployed
        require(zeusToken.approve(address(tokenBridge), amount), "Approval failed");

        uint64 tokenSequence = tokenBridge.transferTokens(
            address(zeusToken),
            amount,
            BASE_CHAIN_ID,
            bytes32(uint256(uint160(recipientWallet))),  // Send to computed UserWallet address
            0,  // arbiter fee
            0   // nonce
        );

        // Security: Verify tokens were actually transferred to bridge
        // Use range checks instead of strict equality to handle edge cases
        uint256 balanceAfterBridge = zeusToken.balanceOf(address(this));
        require(balanceAfterBridge <= balanceAfter - amount, "Bridge did not receive tokens");
        require(balanceAfterBridge >= balanceBefore, "Unexpected balance decrease");

        // Security: Reset approval to 0 (defense in depth)
        zeusToken.approve(address(tokenBridge), 0);

        // 2. Send message via WormholeRelayer (with automatic relay)
        // Note: We send twitterHandle instead of just address for better tracking
        bytes memory payload = abi.encode(
            msg.sender,        // original sender on Ethereum
            twitterHandle,     // twitter handle of recipient
            recipientWallet,   // computed UserWallet address on Base
            amount,            // amount being sent
            tokenSequence      // token transfer sequence number for matching
        );

        uint64 messageSequence = wormholeRelayer.sendPayloadToEvm{value: cost}(
            BASE_CHAIN_ID,
            walletFactoryOnBase,
            payload,
            0,                  // no receiver value
            GAS_LIMIT,
            ETHEREUM_CHAIN_ID,  // refund chain
            msg.sender          // refund address (original sender)
        );

        emit DepositInitiated(msg.sender, twitterHandle, recipientWallet, amount, tokenSequence, messageSequence);

        // Refund excess ETH
        uint256 excess = msg.value - cost;
        if (excess > 0) {
            (bool success, ) = msg.sender.call{value: excess}("");
            require(success, "Refund failed");
        }
    }

    /**
     * @notice Update WalletFactory address on Base
     */
    function setWalletFactoryOnBase(address _factory) external onlyOwner {
        require(_factory != address(0), "Invalid factory");
        walletFactoryOnBase = _factory;
    }

    /**
     * @notice Update UserWallet bytecode hash (if UserWallet contract changes)
     */
    function setUserWalletBytecodeHash(bytes32 _hash) external onlyOwner {
        require(_hash != bytes32(0), "Invalid hash");
        userWalletBytecodeHash = _hash;
    }

    /**
     * @notice Transfer ownership
     */
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Invalid owner");
        address oldOwner = owner;
        owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    /**
     * @notice Receive ETH
     */
    receive() external payable {}
}

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

/**
 * @title IWormholeRelayer
 * @notice Interface for Wormhole Automatic Relayer
 * @dev Used for cross-chain message delivery with automatic relay
 */
interface IWormholeRelayer {
    function quoteEVMDeliveryPrice(
        uint16 targetChain,
        uint256 receiverValue,
        uint256 gasLimit
    ) external view returns (uint256 nativePriceQuote, uint256 targetChainRefundPerGasUnused);

    // Simple version (refunds go to delivery provider)
    function sendPayloadToEvm(
        uint16 targetChain,
        address targetAddress,
        bytes memory payload,
        uint256 receiverValue,
        uint256 gasLimit
    ) external payable returns (uint64 sequence);

    // Full version with refund parameters (REQUIRED for production)
    function sendPayloadToEvm(
        uint16 targetChain,
        address targetAddress,
        bytes memory payload,
        uint256 receiverValue,
        uint256 gasLimit,
        uint16 refundChain,
        address refundAddress
    ) external payable returns (uint64 sequence);
}

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

/**
 * @title ITokenBridge
 * @notice Interface for Wormhole Token Bridge
 */
interface ITokenBridge {
    struct Transfer {
        uint8 payloadID;
        uint256 amount;
        bytes32 tokenAddress;
        uint16 tokenChain;
        bytes32 to;
        uint16 toChain;
        uint256 fee;
    }

    function transferTokens(
        address token,
        uint256 amount,
        uint16 recipientChain,
        bytes32 recipient,
        uint256 arbiterFee,
        uint32 nonce
    ) external payable returns (uint64 sequence);

    function transferTokensWithPayload(
        address token,
        uint256 amount,
        uint16 toChain,
        bytes32 to,
        uint32 batchID,
        bytes memory payload
    ) external payable returns (uint64 sequence);

    function completeTransfer(bytes memory encodedVaa) external returns (bytes memory);

    function completeTransferWithPayload(bytes memory encodedVaa) external returns (bytes memory);

    function parseTransfer(bytes memory encodedVaa) external pure returns (Transfer memory transfer);
}

// 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.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}