Contracts

constructor(
    string memory name_,          // EIP-712 domain name (the deploy passes TOKEN_NAME, "noircash")
    IERC20 noir_,
    IPonsFactory ponsFactory_,
    IPonsCurve curve_,
    IPoolManager poolManager_,
    PoolId poolId_,               // the Pons graduated pool
    IVerifier verifier_,
    IPoseidon2 hasher_,
    IEntryPoint entryPoint_,
    address saleRouter_,          // the PrivateRouter
    address harvester_            // the FeeHarvester
);

struct Transaction {
    uint256 root;            // a root of the note tree the proof was made against
    uint256[2] nullifiers;   // one per input note (dummies included)
    uint256[2] commitments;  // one per output note (dummies included)
    uint256 exitShares;      // shares leaving the private side, gas fee included
    ExtData ext;
}

/// Bound to the proof through extDataHash: nobody can change it after the wallet signs.
struct ExtData {
    address recipient;   // receives exitShares - gasFee, converted to NOIR
    address caller;      // if non-zero, only this address may submit (the router; the vault itself for ERC-4337)
    uint256 gasFee;      // shares, out of exitShares, paid to the gas reserve
    bytes data;          // parameters for `caller`: router sale terms, or the ERC-4337 gas fields
    bytes ciphertext0;   // encrypted data of output note 0
    bytes ciphertext1;   // encrypted data of output note 1
}

struct Keys {
    uint256 opk;       // owner public key, H(nk, wallet key)
    bytes32 viewKey;   // X25519 public key for note encryption
}

/// A sale applied in validation and settled in execution.
struct Sale {
    uint256 amount;
    address ethRecipient;
    uint256 minEthOut;
}

function register(uint256 opk, bytes32 viewKey) external;
function registerFor(address owner, uint256 opk, bytes32 viewKey, uint256 deadline, bytes calldata signature) external;
function keysOf(address owner) external view returns (uint256 opk, bytes32 viewKey);
function registerNonces(address owner) external view returns (uint256);

function shield(uint256 stub, uint256 amount, bytes calldata ciphertext) external returns (uint32 index);
function donate(uint256 amount) external;
function absorb() external returns (uint256 amount);
function transact(Transaction calldata t, bytes calldata proof) external;
function nullifierSpent(uint256 nullifier) external view returns (bool);
function publicInputs(Transaction calldata t) external view returns (bytes32[] memory);
function extDataHash(ExtData memory ext) external pure returns (uint256);

function totalBacking() external view returns (uint256);   // B: NOIR behind all notes
function totalShares() external view returns (uint256);    // S: shares in all notes
function convertToShares(uint256 assets) external view returns (uint256);
function convertToAssets(uint256 shares) external view returns (uint256);

function root() external view returns (uint256);
function isKnownRoot(uint256 root) external view returns (bool);
function nextLeafIndex() external view returns (uint32);
function treeNumber() external view returns (uint32);
function isFinalRoot(uint256 root) external view returns (bool);
function hasher() external view returns (address);

function validateUserOp(PackedUserOperation calldata op, bytes32 userOpHash, uint256 missingAccountFunds)
    external returns (uint256 validationData);
function execute4337(uint256 saleId) external;
function claimSale(uint256 saleId) external;
function addStake(uint32 unstakeDelaySec) external payable;
function pendingSales(uint256 saleId) external view returns (uint256 amount, address ethRecipient, uint256 minEthOut);
function pendingSaleTotal() external view returns (uint256);

function poke() external;
function tokensPerEthEma() external view returns (uint256);
function lastSpot() external view returns (uint192);
function lastPriceBlock() external view returns (uint64);
function gasReserve() external view returns (uint256);
function releaseGasReserve(uint256 max) external returns (uint256 amount);

event KeysRegistered(address indexed owner, uint256 opk, bytes32 viewKey);
event NoteAdded(uint256 indexed index, uint256 commitment, bytes ciphertext);
event Shielded(address indexed from, uint256 indexed index, uint256 amount, uint256 shares);
event Exited(uint256 indexed nullifier, address indexed recipient, uint256 amount, uint256 shares);
event NullifierSpent(uint256 indexed nullifier);
event Donation(address indexed from, uint256 amount);
event GasFeeCollected(uint256 amount);
event PriceUpdated(uint256 tokensPerEthEma);
event SaleSettled(uint256 indexed saleId, bool swapped);
event VaultUpdated(uint256 totalBacking, uint256 totalShares);
event TreeCompleted(uint256 indexed treeNumber, uint256 finalRoot); // from PoseidonMerkleTree

constructor(IPoolManager poolManager_, IPonsFactory ponsFactory_, PrivateVault vault_, address token);

function vault() external view returns (address);
function buy(uint256 stub, uint256 minTokensOut, bytes calldata ciphertext)
    external payable returns (uint32 leafIndex, uint256 tokensOut);
function sell(PrivateVault.Transaction calldata t, bytes calldata proof) external returns (uint256 ethOut);
function onPrivateExit(uint256 amount, address ethRecipient, uint256 minEthOut) external;
function quote(bool isBuy, uint256 amountIn) external returns (uint256 amountOut);
// and everything of PonsSwapper, below

event Bought(uint32 indexed leafIndex, uint256 ethIn, uint256 tokensOut);
event Sold(address indexed ethRecipient, uint256 tokensIn, uint256 ethOut);

error InsufficientOutput();
error NotRoutedHere();
error EthTransferFailed();
error NotVault();

struct Config {
    IPoolManager poolManager;
    IPonsFactory ponsFactory;
    IPonsFeeEscrow feeEscrow;
    IEntryPoint entryPoint;
    PrivateVault vault;          // its CREATE3 address, fixed before it is deployed
    uint256 targetDeposit;
}

constructor(Config memory config, address token); // token: NOIR, already launched on Pons

function MAX_SLIPPAGE_BPS() external view returns (uint256);   // 300
function CALLER_TIP_BPS() external view returns (uint256);     // 50
function entryPoint() external view returns (address);
function feeEscrow() external view returns (address);
function vault() external view returns (address);
function targetDeposit() external view returns (uint256);

function harvest() external returns (uint256 tokensDonated);
function claimable() external view returns (uint256);
// and everything of PonsSwapper, below

event Harvested(uint256 ethClaimed, uint256 ethToDeposit, uint256 ethSpent, uint256 tokensDonated);
event ReserveSold(uint256 tokensIn, uint256 ethOut);
event ReserveDonated(uint256 amount);
event CallerTipped(address indexed caller, uint256 amount);

error EthTransferFailed();
error NotAPonsLaunch();
error NotTheFeeRecipient();
error NotAnEthPair();

function poolManager() external view returns (address);
function ponsFactory() external view returns (address);
function noir() external view returns (address);
function curve() external view returns (address);
function poolId() external view returns (PoolId);
function poolKey() external view returns (PoolKey memory);
function spotPrice() external view returns (uint256);
function onPool() external view returns (bool);
function unlockCallback(bytes calldata data) external returns (bytes memory);
receive() external payable;

error NotPoolManager();
error Quote(uint256 amountOut); // internal: carries the quote out of the reverted swap

// the verifier
interface IVerifier {
    function verify(bytes calldata proof, bytes32[] calldata publicInputs) external view returns (bool);
}

// implemented by PrivateRouter, called by PrivateVault
interface ISaleRouter {
    function onPrivateExit(uint256 amount, address ethRecipient, uint256 minEthOut) external;
}