Documentation

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

/// @title OwedClaimVault
/// @notice Pre-funded, multi-stock reward vault for GetOwed. It holds a basket
/// of tokenized stocks (NVDA, GOOGL, MSFT, AMZN, NFLX, SPOT, QQQ and the rest)
/// and releases a reward only against a GetOwed-signed EIP-712 voucher. Nothing
/// is minted here. Every payout moves stock that is already in the vault, so
/// the on-chain balance is the backing rather than a claim about it.
///
/// The reward `amount` already carries the holder's tier rate. The GetOwed
/// signer reads their $OWED holdings, applies the tier rate (14% at Open up to
/// 75% at Settled) and that tier's monthly ceiling, then signs the final figure.
/// The contract checks the signature, the reward-token allow-list, the
/// single-use id and the deadline. The economics stay off-chain in the signer.
///
/// Non-custodial by construction: there is no owner sweep and no arbitrary
/// execute(). Stock leaves only through claim(). The operator cannot withdraw
/// the backing. Stock flows in by a plain ERC-20 transfer from the treasury,
/// which collects protocol fees, buys the stock and deposits it here.
contract OwedClaimVault is EIP712, Ownable {
    /// @notice Key that co-signs approved rewards. The trust anchor of the vault.
    address public signer;
    bool public paused;

    mapping(address => bool) public isRewardToken; // tokenized-stock allow-list
    mapping(bytes32 => bool) public voucherUsed;   // reward id => redeemed
    mapping(address => uint256) public totalPaid;  // per-token lifetime payout

    bytes32 public constant VOUCHER_TYPEHASH = keccak256(
        "Reward(address token,address to,uint256 amount,bytes32 id,uint256 deadline)"
    );

    event Claimed(address indexed token, address indexed to, uint256 amount, bytes32 indexed id);
    event RewardTokenSet(address indexed token, bool allowed);
    event SignerSet(address indexed signer);
    event PausedSet(bool paused);

    constructor(address signer_, address[] memory rewardTokens_)
        EIP712("GetOwed Rewards", "1")
        Ownable(msg.sender)
    {
        require(signer_ != address(0), "signer=0");
        signer = signer_;
        for (uint256 i = 0; i < rewardTokens_.length; i++) {
            require(rewardTokens_[i] != address(0), "token=0");
            isRewardToken[rewardTokens_[i]] = true;
            emit RewardTokenSet(rewardTokens_[i], true);
        }
    }

    /// @notice Live reserve of one reward stock. The proof-of-reserves read.
    function reserves(address token) external view returns (uint256) {
        return IERC20(token).balanceOf(address(this));
    }

    // ---------------------------------------------------------------- claim ---

    /// @notice Redeem an approved reward. Anyone may relay the voucher, but the
    /// stock always lands at `to`. Single use per `id`, expires at `deadline`.
    function claim(
        address token,
        address to,
        uint256 amount,
        bytes32 id,
        uint256 deadline,
        bytes calldata sig
    ) external {
        require(!paused, "paused");
        require(isRewardToken[token], "token");
        require(to != address(0), "to=0");
        require(block.timestamp <= deadline, "expired");
        require(!voucherUsed[id], "used");

        bytes32 structHash = keccak256(abi.encode(VOUCHER_TYPEHASH, token, to, amount, id, deadline));
        require(ECDSA.recover(_hashTypedDataV4(structHash), sig) == signer, "bad sig");

        voucherUsed[id] = true;
        totalPaid[token] += amount;
        require(IERC20(token).transfer(to, amount), "transfer failed");
        emit Claimed(token, to, amount, id);
    }

    // ---------------------------------------------------------------- admin ---
    // The owner surface is deliberately small. Nothing below moves a reward out
    // of the vault: there is no sweep, no arbitrary execute, no fee pull and no
    // receive(), so ether cannot be trapped here either. Rewards enter through a
    // plain ERC-20 transfer from the treasury EOA and leave only through claim().
    //
    // Rotating `signer` is recorded on-chain via SignerSet, which is what makes
    // the trust anchor auditable rather than merely asserted.

    function setRewardToken(address token, bool allowed) external onlyOwner {
        require(token != address(0), "token=0");
        isRewardToken[token] = allowed;
        emit RewardTokenSet(token, allowed);
    }

    function setSigner(address s) external onlyOwner {
        require(s != address(0), "signer=0");
        signer = s;
        emit SignerSet(s);
    }

    /// @notice Pausing stops payouts and nothing else. It cannot move funds.
    function setPaused(bool p) external onlyOwner {
        paused = p;
        emit PausedSet(p);
    }
}