05 / CONTRACT

EquityAcquisitionTreasuryV2

Everything the treasury can do is written in this one contract. Below is the verbatim source of the PMAX-edition treasury (v2) — the exact code that gets deployed and verified at launch — 471 lines of Solidity, no proxy, no upgrade slots.

Language: Solidity ^0.8.24
License: MIT
Source lines: 471
Network: Robinhood Chain

The four phases the contract encodes

1FUNDreceive()
The creator tax arrives from Pons as plain ETH; receive() books it and announces it.
2WITHDRAWwithdraw()
The operator moves funds toward the brokerage; amount, destination and purpose go on record.
3PURCHASEattestPurchase()
After settlement, the fill comes back on-chain: share count, price, and the broker slip's hash.
4PROGRESSownershipBps()
The contract keeps the whole acquisition ledger and counts the distance to the 13D rung.

Read this first: the trust model

The contract says it up front. The operator has full and immediate custody of the chest — declared in the NatSpec at the top of the source, not buried on a policy page.

NatSpec — TRUST MODEL

L32–38

32 *         TRUST MODEL — read before interacting: this is an experimental
33 *         project. The operator has full, immediate custody of the treasury:
34 *         `withdraw` moves ETH to any address with no delay, and `rescueToken`
35 *         recovers any ERC20 sent here. Real-world share purchases happen
36 *         off-chain and are only as true as the operator's attestations. The
37 *         contract guarantees transparency (every movement is an on-chain
38 *         event), not custody restrictions.

What the contract guarantees is transparency — every movement of funds is an on-chain event — not custody restrictions.

Three thresholds, fixed as constants

The 5% filing line, the 50% control line and the 100% line are compile-time constants — three numbers no key, no vote and no upgrade can move.

Constants — 13D / control / full

L45–55

45    /// @notice Share quantities are stored in micro-shares (1 share = 1e6 units)
46    ///         so fractional brokerage fills can be recorded exactly.
47    uint256 public constant SHARE_SCALE = 1e6;
48 
49    /// @notice SEC Schedule 13D beneficial-ownership disclosure threshold.
50    uint256 public constant DISCLOSURE_BPS = 500; // 5.00%
51 
52    /// @notice Simple-majority voting control threshold.
53    uint256 public constant CONTROL_BPS = 5000; // 50.00% (+1 share)
54 
55    uint256 public constant FULL_BPS = 10000; // 100.00%

Events

L132–149

132    event FeeReceived(address indexed from, uint256 amountWei, uint256 totalFeesReceivedWei);
133    event CreatorFeesClaimed(address indexed escrow, address indexed token, uint256 amount);
134    event Executed(address indexed target, uint256 value, bytes data);
135    event WithdrawalExecuted(uint256 indexed id, uint256 amountWei, address indexed to, string purpose);
136    event TokenRescued(address indexed token, uint256 amount, address indexed to);
137    event PurchaseAttested(
138        uint256 indexed id,
139        uint256 shareUnits,
140        uint256 avgPriceUsdCents,
141        uint256 costUsdCents,
142        uint256 ethSpentWei,
143        bytes32 brokerReceiptHash
144    );
145    event MilestoneReached(uint256 indexed bps, uint256 totalSharesAcquiredUnits, uint256 timestamp);
146    event SharesOutstandingUpdated(uint256 oldUnits, uint256 newUnits, string reason);
147    event ReferencePricesUpdated(uint256 stockPriceUsdCents, uint256 ethPriceUsdCents);
148    event OperatorTransferStarted(address indexed current, address indexed pending);
149    event OperatorTransferred(address indexed previous, address indexed current);

These events are this site's entire data source.

Errors

L155–159

155    error NotOperator();
156    error ZeroAddress();
157    error ZeroAmount();
158    error InsufficientBalance();
159    error TransferFailed();

Custom errors instead of string reverts: cheaper gas, and frontends can identify failures precisely.

The functions that move money, in full

Four pieces of code decide everything this treasury can do. They are short enough to read on a phone. Read them.

1 · FUND — receive()

L194–198

194    /// @notice Pons v2 routes the creator tax here as plain ETH transfers.
195    receive() external payable {
196        totalFeesReceivedWei += msg.value;
197        emit FeeReceived(msg.sender, msg.value, totalFeesReceivedWei);
198    }

The front door. Pons routes the 5% creator tax here as plain ETH; every wei is accrued and announced. (V2 can also pull fees out of Pons's claim escrow — claimCreatorFees, callable by anyone.)

2 · WITHDRAW — withdraw()

L204–230

204    /**
205     * @notice Withdraw treasury ETH. Immediate; destination is free; every
206     *         withdrawal is permanently recorded with its stated purpose.
207     * @param amountWei amount to withdraw; pass 0 to withdraw the full balance
208     * @param to        destination address
209     * @param purpose   stated purpose, e.g. "Broker deposit #2 for PMAX buys"
210     */
211    function withdraw(uint256 amountWei, address to, string calldata purpose)
212        external
213        onlyOperator
214        returns (uint256 id)
215    {
216        if (to == address(0)) revert ZeroAddress();
217        uint256 amount = amountWei == 0 ? address(this).balance : amountWei;
218        if (amount == 0) revert ZeroAmount();
219        if (amount > address(this).balance) revert InsufficientBalance();
220 
221        id = withdrawals.length;
222        withdrawals.push(
223            Withdrawal({amountWei: amount, to: to, executedAt: uint64(block.timestamp), purpose: purpose})
224        );
225        totalWithdrawnWei += amount;
226 
227        (bool ok, ) = to.call{value: amount}("");
228        if (!ok) revert TransferFailed();
229        emit WithdrawalExecuted(id, amount, to, purpose);
230    }

The only way out. Operator-only, immediate, and every call books amount, destination and stated purpose forever.

3 · PURCHASE — attestPurchase()

L307–348

307    /**
308     * @notice Record a completed real-world purchase of target shares.
309     * @param shareUnits         micro-shares bought (1 share = 1e6 units)
310     * @param avgPriceUsdCents   average fill price per whole share, in USD cents
311     * @param ethSpentWei        ETH that was converted to fund this purchase
312     * @param brokerReceiptHash  keccak256 of the broker trade confirmation document
313     * @param executedAt         real-world execution timestamp
314     * @param memo               free-form note, e.g. broker order reference
315     */
316    function attestPurchase(
317        uint256 shareUnits,
318        uint256 avgPriceUsdCents,
319        uint256 ethSpentWei,
320        bytes32 brokerReceiptHash,
321        uint64 executedAt,
322        string calldata memo
323    ) external onlyOperator returns (uint256 id) {
324        if (shareUnits == 0 || avgPriceUsdCents == 0) revert ZeroAmount();
325 
326        uint256 costUsdCents = (shareUnits * avgPriceUsdCents) / SHARE_SCALE;
327        id = purchases.length;
328        purchases.push(
329            Purchase({
330                shareUnits: shareUnits,
331                avgPriceUsdCents: avgPriceUsdCents,
332                costUsdCents: costUsdCents,
333                ethSpentWei: ethSpentWei,
334                executedAt: executedAt,
335                attestedAt: uint64(block.timestamp),
336                brokerReceiptHash: brokerReceiptHash,
337                memo: memo
338            })
339        );
340 
341        totalSharesAcquiredUnits += shareUnits;
342        totalCostUsdCents += costUsdCents;
343 
344        emit PurchaseAttested(id, shareUnits, avgPriceUsdCents, costUsdCents, ethSpentWei, brokerReceiptHash);
345        _checkMilestone(DISCLOSURE_BPS);
346        _checkMilestone(CONTROL_BPS);
347        _checkMilestone(FULL_BPS);
348    }

The bridge back. Off-chain settlements are pinned on-chain with micro-share precision and the broker receipt hash — then the milestone check runs.

4 · PROGRESS — _checkMilestone()

L350–355

350    function _checkMilestone(uint256 bps) internal {
351        if (milestoneReachedAt[bps] == 0 && ownershipBps() >= bps) {
352            milestoneReachedAt[bps] = uint64(block.timestamp);
353            emit MilestoneReached(bps, totalSharesAcquiredUnits, block.timestamp);
354        }
355    }

Crossing 5%, 50% or 100% is recorded automatically, with a timestamp no one can edit.

getStats() — the dashboard's single read

L420–455

420    /// @notice One-call snapshot of everything the dashboard needs.
421    function getStats()
422        external
423        view
424        returns (
425            uint256 balanceWei,
426            uint256 _totalFeesReceivedWei,
427            uint256 _totalWithdrawnWei,
428            uint256 _totalCostUsdCents,
429            uint256 _totalSharesAcquiredUnits,
430            uint256 _sharesOutstandingUnits,
431            uint256 _ownershipBps,
432            uint256 unitsToDisclosure,
433            uint256 unitsToControl,
434            uint256 unitsToFull,
435            uint256 _estimatedAcquirableShareUnits,
436            uint256 _withdrawalsCount,
437            uint256 _purchasesCount
438        )
439    {
440        return (
441            address(this).balance,
442            totalFeesReceivedWei,
443            totalWithdrawnWei,
444            totalCostUsdCents,
445            totalSharesAcquiredUnits,
446            sharesOutstandingUnits,
447            ownershipBps(),
448            shareUnitsToMilestone(DISCLOSURE_BPS),
449            shareUnitsToMilestone(CONTROL_BPS),
450            shareUnitsToMilestone(FULL_BPS),
451            estimatedAcquirableShareUnits(),
452            withdrawals.length,
453            purchases.length
454        );
455    }

One call returns everything this site displays. Call it yourself from any RPC and compare.

Full source

EquityAcquisitionTreasuryV2.sol · 471 lines

EquityAcquisitionTreasuryV2.sol

L1–471

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.24;
3 
4/**
5 * @title EquityAcquisitionTreasuryV2
6 * @notice On-chain treasury for an experimental community campaign to acquire
7 *         real-world equity (NASDAQ: PMAX — Powell Max Limited) funded
8 *         by memecoin trading fees routed from the Pons v2 launchpad on
9 *         Robinhood Chain.
10 *
11 *         V2 adds what v1 lacked: Pons pays creator fees into a pull-based
12 *         escrow ledger that only the fee recipient itself can claim, so the
13 *         recipient must be able to CALL the escrow. V2 can:
14 *           - claimCreatorFees / claimCreatorFeeToken — anyone may trigger a
15 *             claim; proceeds land in this treasury and are booked as fees.
16 *           - execute — operator-only generic call, so no external protocol
17 *             can ever strand funds addressed to this contract again.
18 *
19 *         Lifecycle encoded in this contract:
20 *           1. FUND     — Pons routes the creator tax (ETH) to this contract.
21 *           2. WITHDRAW — the operator withdraws ETH to fund the brokerage
22 *                         account. Every withdrawal is recorded on-chain with
23 *                         destination and purpose.
24 *           3. PURCHASE — after real shares are bought off-chain through the
25 *                         brokerage, the operator attests the purchase on-chain
26 *                         with quantity, price and a hash of the broker receipt.
27 *           4. PROGRESS — the contract keeps the full acquisition ledger and
28 *                         exposes progress toward the SEC 13D disclosure
29 *                         threshold (5%), voting control (50% + 1 share) and
30 *                         full acquisition (100%).
31 *
32 *         TRUST MODEL — read before interacting: this is an experimental
33 *         project. The operator has full, immediate custody of the treasury:
34 *         `withdraw` moves ETH to any address with no delay, and `rescueToken`
35 *         recovers any ERC20 sent here. Real-world share purchases happen
36 *         off-chain and are only as true as the operator's attestations. The
37 *         contract guarantees transparency (every movement is an on-chain
38 *         event), not custody restrictions.
39 */
40contract EquityAcquisitionTreasuryV2 {
41    // ---------------------------------------------------------------------
42    // Constants
43    // ---------------------------------------------------------------------
44 
45    /// @notice Share quantities are stored in micro-shares (1 share = 1e6 units)
46    ///         so fractional brokerage fills can be recorded exactly.
47    uint256 public constant SHARE_SCALE = 1e6;
48 
49    /// @notice SEC Schedule 13D beneficial-ownership disclosure threshold.
50    uint256 public constant DISCLOSURE_BPS = 500; // 5.00%
51 
52    /// @notice Simple-majority voting control threshold.
53    uint256 public constant CONTROL_BPS = 5000; // 50.00% (+1 share)
54 
55    uint256 public constant FULL_BPS = 10000; // 100.00%
56 
57    // ---------------------------------------------------------------------
58    // Target company metadata
59    // ---------------------------------------------------------------------
60 
61    string public targetTicker; // "PMAX"
62    string public targetName; // "Powell Max Limited"
63 
64    /// @notice Total shares outstanding of the target, in micro-shares.
65    ///         Operator-updatable to track splits, buybacks and new issuance.
66    uint256 public sharesOutstandingUnits;
67 
68    // ---------------------------------------------------------------------
69    // Role
70    // ---------------------------------------------------------------------
71 
72    address public operator;
73    address public pendingOperator;
74 
75    // ---------------------------------------------------------------------
76    // Treasury accounting
77    // ---------------------------------------------------------------------
78 
79    uint256 public totalFeesReceivedWei; // lifetime ETH inflow
80    uint256 public totalWithdrawnWei; // lifetime ETH withdrawn
81    uint256 public totalCostUsdCents; // lifetime USD deployed into shares
82    uint256 public totalSharesAcquiredUnits; // micro-shares attested as bought
83 
84    // ---------------------------------------------------------------------
85    // Withdrawals (instant, operator-only, fully recorded)
86    // ---------------------------------------------------------------------
87 
88    struct Withdrawal {
89        uint256 amountWei;
90        address to;
91        uint64 executedAt;
92        string purpose; // e.g. "Broker deposit #3 for PMAX buys"
93    }
94 
95    Withdrawal[] public withdrawals;
96 
97    // ---------------------------------------------------------------------
98    // Purchase attestations
99    // ---------------------------------------------------------------------
100 
101    struct Purchase {
102        uint256 shareUnits; // micro-shares bought
103        uint256 avgPriceUsdCents; // average fill price per whole share, in cents
104        uint256 costUsdCents; // total USD cost of this purchase
105        uint256 ethSpentWei; // ETH converted to fund this purchase
106        uint64 executedAt; // real-world trade timestamp
107        uint64 attestedAt; // block timestamp of this attestation
108        bytes32 brokerReceiptHash; // keccak256 of the broker trade confirmation
109        string memo;
110    }
111 
112    Purchase[] public purchases;
113 
114    // ---------------------------------------------------------------------
115    // Reference prices (operator-attested, for dashboard estimates only)
116    // ---------------------------------------------------------------------
117 
118    uint256 public refStockPriceUsdCents; // last observed target price
119    uint256 public refEthPriceUsdCents; // last observed ETH price
120    uint64 public refPricesUpdatedAt;
121 
122    // ---------------------------------------------------------------------
123    // Milestones
124    // ---------------------------------------------------------------------
125 
126    mapping(uint256 => uint64) public milestoneReachedAt; // bps => timestamp
127 
128    // ---------------------------------------------------------------------
129    // Events
130    // ---------------------------------------------------------------------
131 
132    event FeeReceived(address indexed from, uint256 amountWei, uint256 totalFeesReceivedWei);
133    event CreatorFeesClaimed(address indexed escrow, address indexed token, uint256 amount);
134    event Executed(address indexed target, uint256 value, bytes data);
135    event WithdrawalExecuted(uint256 indexed id, uint256 amountWei, address indexed to, string purpose);
136    event TokenRescued(address indexed token, uint256 amount, address indexed to);
137    event PurchaseAttested(
138        uint256 indexed id,
139        uint256 shareUnits,
140        uint256 avgPriceUsdCents,
141        uint256 costUsdCents,
142        uint256 ethSpentWei,
143        bytes32 brokerReceiptHash
144    );
145    event MilestoneReached(uint256 indexed bps, uint256 totalSharesAcquiredUnits, uint256 timestamp);
146    event SharesOutstandingUpdated(uint256 oldUnits, uint256 newUnits, string reason);
147    event ReferencePricesUpdated(uint256 stockPriceUsdCents, uint256 ethPriceUsdCents);
148    event OperatorTransferStarted(address indexed current, address indexed pending);
149    event OperatorTransferred(address indexed previous, address indexed current);
150 
151    // ---------------------------------------------------------------------
152    // Errors
153    // ---------------------------------------------------------------------
154 
155    error NotOperator();
156    error ZeroAddress();
157    error ZeroAmount();
158    error InsufficientBalance();
159    error TransferFailed();
160 
161    modifier onlyOperator() {
162        if (msg.sender != operator) revert NotOperator();
163        _;
164    }
165 
166    // ---------------------------------------------------------------------
167    // Constructor
168    // ---------------------------------------------------------------------
169 
170    /**
171     * @param _operator          operator address (full treasury custody)
172     * @param _targetTicker      e.g. "PMAX"
173     * @param _targetName        e.g. "Powell Max Limited"
174     * @param _sharesOutstanding whole shares outstanding (NOT scaled), e.g. 1_770_000
175     */
176    constructor(
177        address _operator,
178        string memory _targetTicker,
179        string memory _targetName,
180        uint256 _sharesOutstanding
181    ) {
182        if (_operator == address(0)) revert ZeroAddress();
183        if (_sharesOutstanding == 0) revert ZeroAmount();
184        operator = _operator;
185        targetTicker = _targetTicker;
186        targetName = _targetName;
187        sharesOutstandingUnits = _sharesOutstanding * SHARE_SCALE;
188    }
189 
190    // ---------------------------------------------------------------------
191    // 1. FUND — fee intake
192    // ---------------------------------------------------------------------
193 
194    /// @notice Pons v2 routes the creator tax here as plain ETH transfers.
195    receive() external payable {
196        totalFeesReceivedWei += msg.value;
197        emit FeeReceived(msg.sender, msg.value, totalFeesReceivedWei);
198    }
199 
200    // ---------------------------------------------------------------------
201    // 2. WITHDRAW — instant, operator-only, recorded
202    // ---------------------------------------------------------------------
203 
204    /**
205     * @notice Withdraw treasury ETH. Immediate; destination is free; every
206     *         withdrawal is permanently recorded with its stated purpose.
207     * @param amountWei amount to withdraw; pass 0 to withdraw the full balance
208     * @param to        destination address
209     * @param purpose   stated purpose, e.g. "Broker deposit #2 for PMAX buys"
210     */
211    function withdraw(uint256 amountWei, address to, string calldata purpose)
212        external
213        onlyOperator
214        returns (uint256 id)
215    {
216        if (to == address(0)) revert ZeroAddress();
217        uint256 amount = amountWei == 0 ? address(this).balance : amountWei;
218        if (amount == 0) revert ZeroAmount();
219        if (amount > address(this).balance) revert InsufficientBalance();
220 
221        id = withdrawals.length;
222        withdrawals.push(
223            Withdrawal({amountWei: amount, to: to, executedAt: uint64(block.timestamp), purpose: purpose})
224        );
225        totalWithdrawnWei += amount;
226 
227        (bool ok, ) = to.call{value: amount}("");
228        if (!ok) revert TransferFailed();
229        emit WithdrawalExecuted(id, amount, to, purpose);
230    }
231 
232    /**
233     * @notice Recover any ERC20 tokens sent to this contract (airdrops,
234     *         mistaken transfers, the campaign memecoin itself).
235     * @param token  ERC20 token address
236     * @param amount amount to transfer; pass 0 to transfer the full balance
237     * @param to     destination address
238     */
239    function rescueToken(address token, uint256 amount, address to) external onlyOperator {
240        if (to == address(0)) revert ZeroAddress();
241        uint256 bal = IERC20Minimal(token).balanceOf(address(this));
242        uint256 amt = amount == 0 ? bal : amount;
243        if (amt == 0) revert ZeroAmount();
244        if (amt > bal) revert InsufficientBalance();
245 
246        (bool ok, bytes memory ret) =
247            token.call(abi.encodeWithSelector(IERC20Minimal.transfer.selector, to, amt));
248        // accept both no-return and bool-return ERC20s
249        if (!ok || (ret.length > 0 && !abi.decode(ret, (bool)))) revert TransferFailed();
250        emit TokenRescued(token, amt, to);
251    }
252 
253    // ---------------------------------------------------------------------
254    // 2b. CLAIM — pull creator fees out of Pons's escrow ledger
255    // ---------------------------------------------------------------------
256 
257    /**
258     * @notice Claim this treasury's accrued ETH creator fees from a Pons fee
259     *         escrow. Callable by ANYONE — proceeds can only land here, so an
260     *         open trigger lets the community keep the treasury topped up.
261     *         The ETH arrives through {receive} and is booked as fee inflow.
262     * @param escrow the Pons fee escrow contract (IPonsV2FeeEscrow)
263     */
264    function claimCreatorFees(address escrow) external returns (uint256 amount) {
265        amount = IPonsV2FeeEscrow(escrow).claim();
266        emit CreatorFeesClaimed(escrow, address(0), amount);
267    }
268 
269    /// @notice Same as {claimCreatorFees} for launches whose quote asset is an
270    ///         ERC20 — the tokens land in this contract (recoverable via
271    ///         {rescueToken} or later swapped by the operator).
272    function claimCreatorFeeToken(address escrow, address token) external returns (uint256 amount) {
273        amount = IPonsV2FeeEscrow(escrow).claimToken(token);
274        emit CreatorFeesClaimed(escrow, token, amount);
275    }
276 
277    /**
278     * @notice Operator-only generic call escape hatch. Exists so funds
279     *         addressed to this contract can never again be stranded inside
280     *         an external protocol whose interface we did not anticipate.
281     *         Every use is permanently public via the {Executed} event.
282     */
283    function execute(address target, uint256 value, bytes calldata data)
284        external
285        onlyOperator
286        returns (bytes memory result)
287    {
288        if (target == address(0)) revert ZeroAddress();
289        (bool ok, bytes memory ret) = target.call{value: value}(data);
290        if (!ok) {
291            // bubble the revert reason up
292            if (ret.length > 0) {
293                assembly {
294                    revert(add(ret, 32), mload(ret))
295                }
296            }
297            revert TransferFailed();
298        }
299        emit Executed(target, value, data);
300        return ret;
301    }
302 
303    // ---------------------------------------------------------------------
304    // 3. PURCHASE — on-chain attestation of real-world share purchases
305    // ---------------------------------------------------------------------
306 
307    /**
308     * @notice Record a completed real-world purchase of target shares.
309     * @param shareUnits         micro-shares bought (1 share = 1e6 units)
310     * @param avgPriceUsdCents   average fill price per whole share, in USD cents
311     * @param ethSpentWei        ETH that was converted to fund this purchase
312     * @param brokerReceiptHash  keccak256 of the broker trade confirmation document
313     * @param executedAt         real-world execution timestamp
314     * @param memo               free-form note, e.g. broker order reference
315     */
316    function attestPurchase(
317        uint256 shareUnits,
318        uint256 avgPriceUsdCents,
319        uint256 ethSpentWei,
320        bytes32 brokerReceiptHash,
321        uint64 executedAt,
322        string calldata memo
323    ) external onlyOperator returns (uint256 id) {
324        if (shareUnits == 0 || avgPriceUsdCents == 0) revert ZeroAmount();
325 
326        uint256 costUsdCents = (shareUnits * avgPriceUsdCents) / SHARE_SCALE;
327        id = purchases.length;
328        purchases.push(
329            Purchase({
330                shareUnits: shareUnits,
331                avgPriceUsdCents: avgPriceUsdCents,
332                costUsdCents: costUsdCents,
333                ethSpentWei: ethSpentWei,
334                executedAt: executedAt,
335                attestedAt: uint64(block.timestamp),
336                brokerReceiptHash: brokerReceiptHash,
337                memo: memo
338            })
339        );
340 
341        totalSharesAcquiredUnits += shareUnits;
342        totalCostUsdCents += costUsdCents;
343 
344        emit PurchaseAttested(id, shareUnits, avgPriceUsdCents, costUsdCents, ethSpentWei, brokerReceiptHash);
345        _checkMilestone(DISCLOSURE_BPS);
346        _checkMilestone(CONTROL_BPS);
347        _checkMilestone(FULL_BPS);
348    }
349 
350    function _checkMilestone(uint256 bps) internal {
351        if (milestoneReachedAt[bps] == 0 && ownershipBps() >= bps) {
352            milestoneReachedAt[bps] = uint64(block.timestamp);
353            emit MilestoneReached(bps, totalSharesAcquiredUnits, block.timestamp);
354        }
355    }
356 
357    // ---------------------------------------------------------------------
358    // Operator maintenance
359    // ---------------------------------------------------------------------
360 
361    function updateSharesOutstanding(uint256 newWholeShares, string calldata reason) external onlyOperator {
362        if (newWholeShares == 0) revert ZeroAmount();
363        uint256 old = sharesOutstandingUnits;
364        sharesOutstandingUnits = newWholeShares * SHARE_SCALE;
365        emit SharesOutstandingUpdated(old, sharesOutstandingUnits, reason);
366    }
367 
368    function updateReferencePrices(uint256 stockPriceUsdCents, uint256 ethPriceUsdCents) external onlyOperator {
369        if (stockPriceUsdCents == 0 || ethPriceUsdCents == 0) revert ZeroAmount();
370        refStockPriceUsdCents = stockPriceUsdCents;
371        refEthPriceUsdCents = ethPriceUsdCents;
372        refPricesUpdatedAt = uint64(block.timestamp);
373        emit ReferencePricesUpdated(stockPriceUsdCents, ethPriceUsdCents);
374    }
375 
376    function transferOperator(address newOperator) external onlyOperator {
377        if (newOperator == address(0)) revert ZeroAddress();
378        pendingOperator = newOperator;
379        emit OperatorTransferStarted(operator, newOperator);
380    }
381 
382    function acceptOperator() external {
383        if (msg.sender != pendingOperator) revert NotOperator();
384        address old = operator;
385        operator = pendingOperator;
386        pendingOperator = address(0);
387        emit OperatorTransferred(old, operator);
388    }
389 
390    // ---------------------------------------------------------------------
391    // 4. PROGRESS — views for the dashboard
392    // ---------------------------------------------------------------------
393 
394    /// @notice Current beneficial ownership of the target, in basis points.
395    function ownershipBps() public view returns (uint256) {
396        return (totalSharesAcquiredUnits * FULL_BPS) / sharesOutstandingUnits;
397    }
398 
399    function shareUnitsToMilestone(uint256 bps) public view returns (uint256) {
400        uint256 needed = (sharesOutstandingUnits * bps) / FULL_BPS;
401        return totalSharesAcquiredUnits >= needed ? 0 : needed - totalSharesAcquiredUnits;
402    }
403 
404    /// @notice Micro-shares the current treasury balance could buy at the
405    ///         attested reference prices. Zero if prices are unset.
406    function estimatedAcquirableShareUnits() public view returns (uint256) {
407        if (refStockPriceUsdCents == 0 || refEthPriceUsdCents == 0) return 0;
408        uint256 balanceUsdCents = (address(this).balance * refEthPriceUsdCents) / 1 ether;
409        return (balanceUsdCents * SHARE_SCALE) / refStockPriceUsdCents;
410    }
411 
412    function withdrawalsCount() external view returns (uint256) {
413        return withdrawals.length;
414    }
415 
416    function purchasesCount() external view returns (uint256) {
417        return purchases.length;
418    }
419 
420    /// @notice One-call snapshot of everything the dashboard needs.
421    function getStats()
422        external
423        view
424        returns (
425            uint256 balanceWei,
426            uint256 _totalFeesReceivedWei,
427            uint256 _totalWithdrawnWei,
428            uint256 _totalCostUsdCents,
429            uint256 _totalSharesAcquiredUnits,
430            uint256 _sharesOutstandingUnits,
431            uint256 _ownershipBps,
432            uint256 unitsToDisclosure,
433            uint256 unitsToControl,
434            uint256 unitsToFull,
435            uint256 _estimatedAcquirableShareUnits,
436            uint256 _withdrawalsCount,
437            uint256 _purchasesCount
438        )
439    {
440        return (
441            address(this).balance,
442            totalFeesReceivedWei,
443            totalWithdrawnWei,
444            totalCostUsdCents,
445            totalSharesAcquiredUnits,
446            sharesOutstandingUnits,
447            ownershipBps(),
448            shareUnitsToMilestone(DISCLOSURE_BPS),
449            shareUnitsToMilestone(CONTROL_BPS),
450            shareUnitsToMilestone(FULL_BPS),
451            estimatedAcquirableShareUnits(),
452            withdrawals.length,
453            purchases.length
454        );
455    }
456}
457 
458interface IERC20Minimal {
459    function balanceOf(address) external view returns (uint256);
460    function transfer(address to, uint256 amount) external returns (bool);
461}
462 
463/// @dev Pons v2 shared fee escrow — a pull-based claimable balance ledger.
464///      claim()/claimToken() pay out msg.sender's own accrued balance.
465interface IPonsV2FeeEscrow {
466    function claim() external returns (uint256 amount);
467    function claimToken(address token) external returns (uint256 amount);
468    function balanceOf(address recipient) external view returns (uint256);
469    function balanceOfToken(address recipient, address token) external view returns (uint256);
470}

Scrolls within its frame. Once the v2 treasury is deployed, diff this line-by-line against the verified source on the block explorer.

Contract addressBack to the method