Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import {IBlast, IBlastPoints} from "./interfaces/IBlast.sol";
import {IGame} from "./interfaces/IGame.sol";
import {IPXUETH} from "./interfaces/IPXUETH.sol";

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

/**
 * @title Game contract
 * @notice Used to call the deposit function of the PXUETH contract
 */
contract Game is Ownable, IGame {
    IPXUETH public immutable pxu;
    IBlast public immutable blast;

    mapping(address => uint256) public ethStaked;

    /**
     * @notice Initializes the Game contract and stores the PXUETH contract
     * @param _pxu The address of the PXUETH contract
     * @param _blastPoints Blast points contract
     * @param _blastPointOperator An operator to receive the Blast points from the API
     */
    constructor(address _pxu, address _blastPoints, address _blastPointOperator, address _blast) Ownable(msg.sender) {
        pxu = IPXUETH(_pxu);
        blast = IBlast(_blast);

        blast.configureClaimableGas();
        IBlastPoints(_blastPoints).configurePointsOperator(_blastPointOperator);
    }

    /**
     * @notice Deposits ETH to the PXUETH vault contract
     */
    function deposit() external payable {
        pxu.deposit{value: msg.value}(msg.sender);

        ethStaked[msg.sender] += msg.value;

        emit ETHStaked(msg.sender, msg.value);
    }

    /**
     * @notice Withdraws ETH from the PXUETH vault
     * @param _amount Amount of PXUETH to burn
     */
    function withdraw(uint256 _amount) external {
        uint256 amount = _amount;

        uint256 totalUserBalance = ethStaked[msg.sender];

        if (_amount == 0) {
            amount = totalUserBalance;
        }

        if (ethStaked[msg.sender] < amount) {
            revert InsufficientBalance();
        }

        ethStaked[msg.sender] -= amount;
        pxu.withdraw(msg.sender, amount);

        emit ETHWithdrawn(msg.sender, amount);
    }

    /**
     * @notice Claim all gas by owner
     * @param _recipient Recipient of the gas
     */
    function claimAllGas(address _recipient) external onlyOwner {
        blast.claimMaxGas(address(this), _recipient);
    }
}

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

enum YieldMode {
    AUTOMATIC,
    VOID,
    CLAIMABLE
}

enum GasMode {
    VOID,
    CLAIMABLE
}

interface IERC20Rebasing {
    function configure(YieldMode) external returns (uint256);

    function claim(address recipient, uint256 amount) external returns (uint256);

    function getClaimableAmount(address account) external view returns (uint256);
}

interface IBlast {
    function configureClaimableYield() external;

    function configureAutomaticYield() external;

    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);

    function configureClaimableGas() external;

    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);

    function readClaimableYield(address contractAddress) external view returns (uint256);

    function configureVoidYield() external;

    function claimMaxGas(address contractAddress, address recipient) external returns (uint256);

    function configureGovernor(address _governor) external;
}

interface IBlastPoints {
    function configurePointsOperator(address operator) external;
}

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

/**
 * @title Game contract
 * @notice Used to call the deposit function of the PXUETH contract
 */
interface IGame {
    /**
     * @notice ETH staked to the PXUETH vault
     * @param _account Account to deposit
     * @param _amount Amount of ETH to deposit
     */
    event ETHStaked(address _account, uint256 _amount);

    /**
     * @notice ETH withdrawn from the PXUETH vault
     * @param _account Account to withdraw
     * @param _amount Amount of PXUETH to burn
     */
    event ETHWithdrawn(address _account, uint256 _amount);

    error InsufficientBalance();

    /**
     * @notice Deposits ETH to the PXUETH vault contract
     */
    function deposit() external payable;

    /**
     * @notice Withdraws ETH from the PXUETH vault
     * @param _amount Amount of PXUETH to burn
     */
    function withdraw(uint256 _amount) external;

    /**
     * @notice Claim all gas by owner
     * @param _recipient Recipient of the gas
     */
    function claimAllGas(address _recipient) external;
}

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

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

/**
 * @title PXUETH ERC20 contract
 * @notice PXUETH a contract used to stake ETH and get PXUETH on a 1:1 ratio and claim yield
 */
interface IPXUETH is IAccessControl, IERC20 {
    /**
     * @notice Emitted when the Game contracts call the deposit
     * @param _amount Amount of ETH deposited
     * @param _sender The caller of the game contract
     * @param _game The address of the game contract
     * @param _timestamp The address of the game contract
     */
    event Deposit(uint256 _amount, address indexed _sender, address indexed _game, uint256 _timestamp);

    /**
     * @notice Emitted when the caller withdraws ETH and burns PXUETH
     * @param _amount Amount of PXUETH burned
     * @param _sender The caller of the contract
     * @param _timestamp The block timestamp when withdraw happened
     */
    event Withdraw(uint256 _amount, address indexed _sender, uint256 _timestamp);

    /**
     * @notice Emitted when the admin of the contract calls emergency withdraw
     * @param _recipient Recipient that receives the Ether
     * @param _amount Total amount of ETH in the contract that is transferred to the recipient
     */
    event EmergencyWithdrawn(address indexed _recipient, uint256 _amount);

    /**
     * @notice Emitted when a holder claims their ETH yield
     * @param _account Holder of PXUETH tokens
     * @param _amount Amount of yield transferred to the holder
     * @param _duration Duration of the staked tokens minus the CLAIMABLE_AFTER
     */
    event YieldClaimed(address _account, uint256 _amount, uint256 _duration);

    /**
     * @notice Thrown when the contract fails to send ETH to the user
     */
    error FailedToSendEther();

    /**
     * @notice Configures the yield to be claimable
     * @dev Can only be called by the admin of the contract
     */
    function configureYield() external;

    /**
     * @notice Claim all gas by owner
     * @param _recipient Recipient of the gas
     */
    function claimAllGas(address _recipient) external;

    /**
     * @notice Mints PXUETH on a 1:1 ratio with ETH and transfers past yields
     * @param _account The address of the account
     */
    function deposit(address _account) external payable;

    /**
     * @notice Burns PXUETH and transfers the same amount of ETH to the caller
     * @param _account The holder of the PXUETH tokens
     * @param _amount Amount of PXUETH a holder wants to burn
     */
    function withdraw(address _account, uint256 _amount) external;

    /**
     * @notice Withdraws the total amount of ETH in the contract in case of emergency
     * @param _recipient Address of the recipient
     * @return totalBalance Total amount of ETH transferred to the recipient
     */
    function emergencyWithdraw(address _recipient) external returns (uint256 totalBalance);

    /**
     * @notice Calculates the yield of the holder based on the amount and duration of staking and
     * transfers it to the holder
     * @param _account The holder of the PXUETH token
     */
    function claimYield(address _account) external;

    /**
     * @notice Returns the claimable yield of a holder
     * @param _account Holder of the PXUETH
     * @return The amount of yield in ETH
     */
    function getClaimYield(address _account) external view returns (uint256);
}

// 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.0.0) (access/IAccessControl.sol)

pragma solidity ^0.8.20;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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;
    }
}

{
  "remappings": [
    "@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/",
    "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    "ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_pxu","type":"address"},{"internalType":"address","name":"_blastPoints","type":"address"},{"internalType":"address","name":"_blastPointOperator","type":"address"},{"internalType":"address","name":"_blast","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_account","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"ETHStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_account","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"ETHWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"blast","outputs":[{"internalType":"contract IBlast","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"claimAllGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"ethStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pxu","outputs":[{"internalType":"contract IPXUETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000d749ae3014777edc57f721fdb640a8085233ae700000000000000000000000002536fe9ab3f511540f2f9e2ec2a805005c3dd80000000000000000000000000045fc16fbaea404d42ee15c281054691cc3c351b40000000000000000000000004300000000000000000000000000000000000002

-----Decoded View---------------
Arg [0] : _pxu (address): 0xd749aE3014777eDC57F721FdB640a8085233ae70
Arg [1] : _blastPoints (address): 0x2536FE9ab3F511540F2f9e2eC2A805005C3Dd800
Arg [2] : _blastPointOperator (address): 0x45FC16fBAea404d42eE15C281054691cc3C351b4
Arg [3] : _blast (address): 0x4300000000000000000000000000000000000002

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000d749ae3014777edc57f721fdb640a8085233ae70
Arg [1] : 0000000000000000000000002536fe9ab3f511540f2f9e2ec2a805005c3dd800
Arg [2] : 00000000000000000000000045fc16fbaea404d42ee15c281054691cc3c351b4
Arg [3] : 0000000000000000000000004300000000000000000000000000000000000002