The Contract

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

/*
 * ────────────────────────────────────────────────────────────────────────────
 *  GADFLY FUND
 *  The smallest activist fund in the world.
 *  AUM: one share. Fully exercised.
 *
 *  Deployed on Robinhood Chain (chainId 4663).
 *
 *  The contract is a notarized diary that grew a coin pocket. The one share
 *  lives off-chain in the operator's custody; the treasury that pays for
 *  the stamps lives here, fed by the GADFLY token's trading tax, and is
 *  withdrawable by the operator alone, without restriction, as disclosed.
 *  It records six kinds of facts:
 *
 *    1. Letters, under commit-reveal. The keccak256 hash of a letter's full
 *       UTF-8 text is locked on-chain BEFORE the letter is mailed. After
 *       mailing, the full text is revealed and the contract checks that the
 *       published text hashes to the locked commitment. This equality is the
 *       only trustless moment in the entire system: it proves that the letter
 *       the public reads is the letter the CEO received. Everything else is
 *       testimony.
 *    2. Mailing receipts and replies, as document hashes (testimony).
 *    3. The state of the one share: HOLDING or ERASED, with counters for how
 *       many times corporate arithmetic (reverse splits) deleted the share
 *       and how many times the fund bought it back. The Theseus clause.
 *    4. Expenses, in integer US cents, by category (testimony).
 *    5. Income, likewise: token-tax sweeps and anything else that funds
 *       the rites (testimony).
 *    6. Annual-meeting attendance and the one question asked each year
 *       (testimony).
 *
 *  This file is the canonical contract: the tests, the deploy script, and
 *  the site's ABI are all derived from it.
 * ────────────────────────────────────────────────────────────────────────────
 */

contract GadflyFund {
    // ── Errors ──────────────────────────────────────────────────────────────

    error NotOperator();
    error ZeroAddress();
    error EmptyCommitment();
    error NothingCommitted();
    error AlreadyRevealed();
    error BadReveal();
    error NotHolding();
    error NotErased();
    error EthTransferFailed();
    error TokenTransferFailed();

    // ── Types ───────────────────────────────────────────────────────────────

    enum ShareState {
        HOLDING,
        ERASED
    }

    struct Letter {
        bytes32 commitment;  // keccak256 of the letter's full UTF-8 text
        uint64 committedAt;  // block timestamp of the commit
        uint64 revealedAt;   // 0 while the letter is still sealed
        uint64 mailedAt;     // 0 until a mailing receipt is recorded
        uint64 repliedAt;    // 0 while the company is silent
        bytes32 receiptHash; // hash of the registered-mail receipt scan
        bytes32 replyHash;   // hash of the company's reply scan; 0 = silence
        string uri;          // where the revealed full text is published
    }

    struct Expense {
        bytes32 category;    // short tag, e.g. bytes32("POSTAGE")
        uint128 amountCents; // US cents; the fund thinks in stamps
        uint64 recordedAt;
        string memo;
    }

    struct Income {
        bytes32 category;    // e.g. bytes32("TAX") for token-tax sweeps
        uint128 amountCents; // USD value as recorded by the operator
        uint64 recordedAt;
        string memo;
    }

    struct Meeting {
        uint16 year;              // meeting year, e.g. 2025
        bool attendedInPerson;
        bool questionReadAloud;   // was the question read / asked on the floor
        bool answered;            // did any answer follow, of any quality
        uint64 recordedAt;
        bytes32 evidenceHash;     // hash of the operator's notes or exhibits
        string question;          // the one question, verbatim
    }

    // ── Events ──────────────────────────────────────────────────────────────

    event LetterCommitted(uint256 indexed id, bytes32 commitment, uint256 at);
    event LetterRevealed(uint256 indexed id, bytes32 commitment, string uri, uint256 at);
    event LetterMailed(uint256 indexed id, bytes32 receiptHash, uint256 at);
    event ReplyRecorded(uint256 indexed id, bytes32 replyHash, uint256 at);
    event ShareErased(uint256 timesErased, string note, uint256 at);
    event ShareRestored(uint256 timesRestored, string note, uint256 at);
    event ExpenseRecorded(
        uint256 indexed id, bytes32 indexed category, uint128 amountCents, string memo, uint256 at
    );
    event IncomeRecorded(
        uint256 indexed id, bytes32 indexed category, uint128 amountCents, string memo, uint256 at
    );
    event Received(address indexed from, uint256 amount);
    event EthWithdrawn(address indexed to, uint256 amount);
    event TokenWithdrawn(address indexed token, address indexed to, uint256 amount);
    event MeetingRecorded(
        uint256 indexed id,
        uint16 indexed year,
        bool attendedInPerson,
        bool questionReadAloud,
        bool answered,
        uint256 at
    );
    event OperatorChanged(address indexed previousOperator, address indexed newOperator);

    // ── Storage ─────────────────────────────────────────────────────────────

    address public operator;
    string public target; // ticker of the company whose one share the fund holds
    uint64 public immutable inceptionAt;

    ShareState public shareState; // HOLDING at deployment
    uint64 public timesErased;
    uint64 public timesRestored;

    uint256 public totalSpentCents;
    uint256 public totalReceivedCents;

    Letter[] private _letters;
    Expense[] private _expenses;
    Income[] private _income;
    Meeting[] private _meetings;

    // ── Modifiers ───────────────────────────────────────────────────────────

    modifier onlyOperator() {
        if (msg.sender != operator) revert NotOperator();
        _;
    }

    constructor(string memory target_) {
        operator = msg.sender;
        target = target_;
        inceptionAt = uint64(block.timestamp);
    }

    // ── Letters: the one trustless moment ───────────────────────────────────

    /// Lock the hash of a letter's full text before it is mailed.
    function commitLetter(bytes32 commitment) external onlyOperator returns (uint256 id) {
        if (commitment == bytes32(0)) revert EmptyCommitment();
        _letters.push();
        id = _letters.length - 1;
        Letter storage l = _letters[id];
        l.commitment = commitment;
        l.committedAt = uint64(block.timestamp);
        emit LetterCommitted(id, commitment, block.timestamp);
    }

    /// Publish the full text. The contract checks it against the commitment.
    /// This check is the only statement in the system that does not require
    /// trusting the operator.
    function revealLetter(uint256 id, string calldata fullText, string calldata uri)
        external
        onlyOperator
    {
        if (id >= _letters.length) revert NothingCommitted();
        Letter storage l = _letters[id];
        if (l.revealedAt != 0) revert AlreadyRevealed();
        if (keccak256(bytes(fullText)) != l.commitment) revert BadReveal();
        l.revealedAt = uint64(block.timestamp);
        l.uri = uri;
        emit LetterRevealed(id, l.commitment, uri, block.timestamp);
    }

    /// Record the hash of the registered-mail receipt. Testimony, not proof:
    /// the chain cannot watch a letter enter a mailbox.
    function recordMailing(uint256 id, bytes32 receiptHash) external onlyOperator {
        if (id >= _letters.length) revert NothingCommitted();
        Letter storage l = _letters[id];
        l.mailedAt = uint64(block.timestamp);
        l.receiptHash = receiptHash;
        emit LetterMailed(id, receiptHash, block.timestamp);
    }

    /// Record the hash of a reply, should one ever arrive.
    function recordReply(uint256 id, bytes32 replyHash) external onlyOperator {
        if (id >= _letters.length) revert NothingCommitted();
        Letter storage l = _letters[id];
        l.repliedAt = uint64(block.timestamp);
        l.replyHash = replyHash;
        emit ReplyRecorded(id, replyHash, block.timestamp);
    }

    // ── The Theseus clause ──────────────────────────────────────────────────

    /// A reverse split (or similar corporate act) deleted the share.
    function markErased(string calldata note) external onlyOperator {
        if (shareState != ShareState.HOLDING) revert NotHolding();
        shareState = ShareState.ERASED;
        timesErased += 1;
        emit ShareErased(timesErased, note, block.timestamp);
    }

    /// The fund bought the share back. Same fund, new plank.
    function markRestored(string calldata note) external onlyOperator {
        if (shareState != ShareState.ERASED) revert NotErased();
        shareState = ShareState.HOLDING;
        timesRestored += 1;
        emit ShareRestored(timesRestored, note, block.timestamp);
    }

    // ── The ledger ──────────────────────────────────────────────────────────

    function recordExpense(bytes32 category, uint128 amountCents, string calldata memo)
        external
        onlyOperator
        returns (uint256 id)
    {
        _expenses.push(
            Expense({
                category: category,
                amountCents: amountCents,
                recordedAt: uint64(block.timestamp),
                memo: memo
            })
        );
        id = _expenses.length - 1;
        totalSpentCents += amountCents;
        emit ExpenseRecorded(id, category, amountCents, memo, block.timestamp);
    }

    function recordIncome(bytes32 category, uint128 amountCents, string calldata memo)
        external
        onlyOperator
        returns (uint256 id)
    {
        _income.push(
            Income({
                category: category,
                amountCents: amountCents,
                recordedAt: uint64(block.timestamp),
                memo: memo
            })
        );
        id = _income.length - 1;
        totalReceivedCents += amountCents;
        emit IncomeRecorded(id, category, amountCents, memo, block.timestamp);
    }

    // ── The treasury ────────────────────────────────────────────────────────
    // The token's trading tax lands here, in GADFLY and eventually in ETH.
    // The operator withdraws it to buy stamps and seats, and records what
    // everything was worth via recordIncome / recordExpense. The withdrawals
    // are unrestricted by design and disclosed as such: this fund's deepest
    // dependency has always been the operator's honesty.

    receive() external payable {
        emit Received(msg.sender, msg.value);
    }

    function withdrawEth(address payable to, uint256 amount) external onlyOperator {
        if (to == address(0)) revert ZeroAddress();
        (bool ok,) = to.call{value: amount}("");
        if (!ok) revert EthTransferFailed();
        emit EthWithdrawn(to, amount);
    }

    function withdrawToken(address token, address to, uint256 amount) external onlyOperator {
        if (to == address(0)) revert ZeroAddress();
        // transfer(address,uint256); tolerate ERC-20s that return nothing.
        (bool ok, bytes memory data) =
            token.call(abi.encodeWithSelector(0xa9059cbb, to, amount));
        if (!ok || (data.length != 0 && !abi.decode(data, (bool)))) {
            revert TokenTransferFailed();
        }
        emit TokenWithdrawn(token, to, amount);
    }

    // ── The question ────────────────────────────────────────────────────────

    function recordMeeting(
        uint16 year,
        bool attendedInPerson,
        string calldata question,
        bool questionReadAloud,
        bool answered,
        bytes32 evidenceHash
    ) external onlyOperator returns (uint256 id) {
        _meetings.push(
            Meeting({
                year: year,
                attendedInPerson: attendedInPerson,
                questionReadAloud: questionReadAloud,
                answered: answered,
                recordedAt: uint64(block.timestamp),
                evidenceHash: evidenceHash,
                question: question
            })
        );
        id = _meetings.length - 1;
        emit MeetingRecorded(id, year, attendedInPerson, questionReadAloud, answered, block.timestamp);
    }

    // ── Operator ────────────────────────────────────────────────────────────

    function setOperator(address newOperator) external onlyOperator {
        if (newOperator == address(0)) revert ZeroAddress();
        emit OperatorChanged(operator, newOperator);
        operator = newOperator;
    }

    // ── Views ───────────────────────────────────────────────────────────────

    function lettersCount() external view returns (uint256) {
        return _letters.length;
    }

    function getLetter(uint256 id) external view returns (Letter memory) {
        if (id >= _letters.length) revert NothingCommitted();
        return _letters[id];
    }

    function expensesCount() external view returns (uint256) {
        return _expenses.length;
    }

    function getExpense(uint256 id) external view returns (Expense memory) {
        return _expenses[id];
    }

    function incomeCount() external view returns (uint256) {
        return _income.length;
    }

    function getIncome(uint256 id) external view returns (Income memory) {
        return _income[id];
    }

    function meetingsCount() external view returns (uint256) {
        return _meetings.length;
    }

    function getMeeting(uint256 id) external view returns (Meeting memory) {
        return _meetings[id];
    }

    /// One call for the site's front page.
    function counters()
        external
        view
        returns (
            uint256 letters_,
            uint256 expenses_,
            uint256 meetings_,
            uint64 erased_,
            uint64 restored_,
            ShareState state_,
            uint256 totalSpentCents_
        )
    {
        return (
            _letters.length,
            _expenses.length,
            _meetings.length,
            timesErased,
            timesRestored,
            shareState,
            totalSpentCents
        );
    }
}