Contract Address Details

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.20;

// ──────────────────────────────────────────────
// INTERFACES
// ──────────────────────────────────────────────
interface GemLike {
    function transfer(address dst, uint256 wad) external returns (bool);
    function transferFrom(address src, address dst, uint256 wad) external returns (bool);
    function approve(address usr, uint256 wad) external returns (bool);
    function balanceOf(address usr) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function decimals() external view returns (uint8);
}

interface DaiLike is GemLike {
    function push(address usr, uint256 wad) external;
    function pull(address usr, uint256 wad) external;
    function move(address src, address dst, uint256 wad) external;
    function mint(address usr, uint256 wad) external;
    function burn(address usr, uint256 wad) external;
    function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external;
}

interface DaiJoinLike {
    function vat() external view returns (address);
    function dai() external view returns (address);
    function join(address usr, uint256 wad) external;
    function exit(address usr, uint256 wad) external;
}

interface VatLike {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function can(address, address) external view returns (uint256);
    function hope(address) external;
    function nope(address) external;
    function ilks(bytes32) external view returns (uint256, uint256, uint256, uint256, uint256);
    function urns(bytes32, address) external view returns (uint256, uint256);
    function gem(bytes32, address) external view returns (uint256);
    function dai(address) external view returns (uint256);
    function sin(address) external view returns (uint256);
    function debt() external view returns (uint256);
    function vice() external view returns (uint256);
    function Line() external view returns (uint256);
    function live() external view returns (uint256);
    function init(bytes32) external;
    function file(bytes32, uint256) external;
    function file(bytes32, bytes32, uint256) external;
    function cage() external;
    function slip(bytes32, address, int256) external;
    function flux(bytes32, address, address, uint256) external;
    function move(address, address, uint256) external;
    function frob(bytes32, address, address, address, int256, int256) external;
    function fork(bytes32, address, address, int256, int256) external;
    function grab(bytes32, address, address, address, int256, int256) external;
    function heal(uint256) external;
    function suck(address, address, uint256) external;
    function fold(bytes32, address, int256) external;
}

interface GemJoinLike {
    function vat() external view returns (address);
    function ilk() external view returns (bytes32);
    function gem() external view returns (address);
    function dec() external view returns (uint8);
    function join(address usr, uint256 wad) external;
    function exit(address usr, uint256 wad) external;
}

interface SpotterLike {
    function rely(address usr) external;
    function file(bytes32 ilk, bytes32 what, address pip) external;
    function file(bytes32 ilk, bytes32 what, uint256 data) external;
    function poke(bytes32 ilk) external;
    function par() external view returns (uint256);
    function ilks(bytes32) external view returns (PipLike, uint256);
}

interface DogLike {
    function rely(address usr) external;
    function file(bytes32 ilk, bytes32 what, address clip) external;
    function file(bytes32 ilk, bytes32 what, uint256 data) external;
    function chop(bytes32) external view returns (uint256);
    function digs(bytes32, uint256) external;
}

interface PaiRegistryLike {
    function addIlk(bytes32 ilk, address gem, address join, address pip, address clip, address pair, address psm) external;
}

interface ISimpleTWAPOracle {
    function getPriceInUsd(address token, uint amountIn) external view returns (uint amountOutDai);
}

interface IERC20 {
    function decimals() external view returns (uint8);
}




interface PipLike {
    function peek() external view returns (bytes32, bool);
}



interface ClipperCallee {
    function clipperCall(address, uint256, uint256, bytes calldata) external;
}

interface AbacusLike {
    function price(uint256, uint256) external view returns (uint256);
}

contract Clipper {
    // ─── Errors ───
    error NotAuthorized();
    error SystemLocked();
    error StoppedIncorrect();
    error FileUnrecognizedParam();
    error ZeroTab();
    error ZeroLot();
    error ZeroUsr();
    error Overflow();
    error ZeroTopPrice();
    error NotRunningAuction();
    error CannotReset();
    error NeedsReset();
    error TooExpensive();
    error NoPartialPurchase();
    error InvalidPrice();

    // ─── Auth ───
    mapping(address => uint256) public wards;
    modifier auth {
        if (wards[msg.sender] != 1) revert NotAuthorized();
        _;
    }

    // ─── Data ───
    bytes32 public immutable ilk;
    VatLike public immutable vat;

    DogLike     public dog;
    address     public vow;
    SpotterLike public spotter;
    AbacusLike  public calc;

    uint256 public buf;
    uint256 public tail;
    uint256 public cusp;
    uint64  public chip;
    uint192 public tip;
    uint256 public chost;

    uint256   public kicks;
    uint256[] public active;

    struct Sale {
        uint256 pos;
        uint256 tab;
        uint256 lot;
        address usr;
        uint96  tic;
        uint256 top;
    }
    mapping(uint256 => Sale) public sales;

    uint256 internal locked;
    uint256 public stopped = 0;

    // ─── Events ───
    event Rely(address indexed usr);
    event Deny(address indexed usr);
    event File(bytes32 indexed what, uint256 data);
    event FileAddress(bytes32 indexed what, address data);
    event Kick(uint256 indexed id, uint256 top, uint256 tab, uint256 lot, address indexed usr, address indexed kpr, uint256 coin);
    event Take(uint256 indexed id, uint256 max, uint256 price, uint256 owe, uint256 tab, uint256 lot, address indexed usr);
    event Redo(uint256 indexed id, uint256 top, uint256 tab, uint256 lot, address indexed usr, address indexed kpr, uint256 coin);
    event Yank(uint256 indexed id);
    event Upchost(uint256 chost);

    // ─── Init ───
    constructor(address vat_, address spotter_, address dog_, bytes32 ilk_) {
        vat     = VatLike(vat_);
        spotter = SpotterLike(spotter_);
        dog     = DogLike(dog_);
        ilk     = ilk_;
        buf     = RAY;
        wards[msg.sender] = 1;
        emit Rely(msg.sender);
    }

    // ─── Sync ───
    modifier lock {
        if (locked == 1) revert SystemLocked();
        locked = 1;
        _;
        locked = 0;
    }

    modifier isStopped(uint256 level) {
        if (stopped >= level) revert StoppedIncorrect();
        _;
    }

    // ─── Admin ───
    function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
    function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }

    function file(bytes32 what, uint256 data) external auth lock {
        if      (what == "buf")     buf = data;
        else if (what == "tail")    tail = data;
        else if (what == "cusp")    cusp = data;
        else if (what == "chip")    chip = uint64(data);
        else if (what == "tip")     tip = uint192(data);
        else if (what == "stopped") stopped = data;
        else revert FileUnrecognizedParam();
        emit File(what, data);
    }

    function file(bytes32 what, address data) external auth lock {
        if      (what == "spotter") spotter = SpotterLike(data);
        else if (what == "dog")     dog = DogLike(data);
        else if (what == "vow")     vow = data;
        else if (what == "calc")    calc = AbacusLike(data);
        else revert FileUnrecognizedParam();
        emit FileAddress(what, data);
    }

    // ─── Math ───
    uint256 constant BLN = 10 **  9;
    uint256 constant WAD = 10 ** 18;
    uint256 constant RAY = 10 ** 27;

    function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = (x * y) / RAY;
    }
    function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = (x * RAY) / y;
    }

    // ─── Auction ───
    function getFeedPrice() internal view returns (uint256 feedPrice) {
        (PipLike pip, ) = spotter.ilks(ilk);
        (bytes32 val, bool has) = pip.peek();
        if (!has) revert InvalidPrice();
        feedPrice = rdiv(uint256(val) * BLN, spotter.par());
    }

    function kick(
        uint256 tab, uint256 lot, address usr, address kpr
    ) external auth lock isStopped(1) returns (uint256 id) {
        if (tab == 0)         revert ZeroTab();
        if (lot == 0)         revert ZeroLot();
        if (usr == address(0)) revert ZeroUsr();
        
        id = ++kicks;
        if (id == 0) revert Overflow();

        active.push(id);
        sales[id].pos = active.length - 1;
        sales[id].tab = tab;
        sales[id].lot = lot;
        sales[id].usr = usr;
        sales[id].tic = uint96(block.timestamp);

        uint256 top = rmul(getFeedPrice(), buf);
        if (top == 0) revert ZeroTopPrice();
        sales[id].top = top;

        uint256 _tip  = tip;
        uint256 _chip = chip;
        if (_tip > 0 || _chip > 0) {
            uint256 coin = _tip + ((tab * _chip) / WAD);
            vat.suck(vow, kpr, coin);
            emit Kick(id, top, tab, lot, usr, kpr, coin);
        } else {
            emit Kick(id, top, tab, lot, usr, kpr, 0);
        }
    }

    function redo(uint256 id, address kpr) external lock isStopped(2) {
        address usr = sales[id].usr;
        if (usr == address(0)) revert NotRunningAuction();

        (bool done,) = status(sales[id].tic, sales[id].top);
        if (!done) revert CannotReset();

        uint256 tab = sales[id].tab;
        uint256 lot = sales[id].lot;
        sales[id].tic = uint96(block.timestamp);

        uint256 feedPrice = getFeedPrice();
        uint256 top = rmul(feedPrice, buf);
        if (top == 0) revert ZeroTopPrice();
        sales[id].top = top;

        uint256 _tip  = tip;
        uint256 _chip = chip;
        if (_tip > 0 || _chip > 0) {
            uint256 _chost = chost;
            if (tab >= _chost && lot * feedPrice >= _chost) {
                uint256 coin = _tip + ((tab * _chip) / WAD);
                vat.suck(vow, kpr, coin);
                emit Redo(id, top, tab, lot, usr, kpr, coin);
            } else {
                emit Redo(id, top, tab, lot, usr, kpr, 0);
            }
        } else {
            emit Redo(id, top, tab, lot, usr, kpr, 0);
        }
    }

    function take(
        uint256 id, uint256 amt, uint256 max, address who, bytes calldata data
    ) external lock isStopped(3) {
        address usr = sales[id].usr;
        if (usr == address(0)) revert NotRunningAuction();

        uint256 price;
        {
            bool done;
            (done, price) = status(sales[id].tic, sales[id].top);
            if (done) revert NeedsReset();
        }

        if (max < price) revert TooExpensive();

        uint256 lot = sales[id].lot;
        uint256 tab = sales[id].tab;
        uint256 owe;

        {
            uint256 slice = lot <= amt ? lot : amt;
            owe = slice * price;

            if (owe > tab) {
                owe = tab;
                slice = owe / price;
            } else if (owe < tab && slice < lot) {
                uint256 _chost = chost;
                if (tab - owe < _chost) {
                    if (tab <= _chost) revert NoPartialPurchase();
                    owe = tab - _chost;
                    slice = owe / price;
                }
            }

            tab = tab - owe;
            lot = lot - slice;

            vat.flux(ilk, address(this), who, slice);

            DogLike dog_ = dog;
            if (data.length > 0 && who != address(vat) && who != address(dog_)) {
                ClipperCallee(who).clipperCall(msg.sender, owe, slice, data);
            }

            vat.move(msg.sender, vow, owe);
            dog_.digs(ilk, lot == 0 ? tab + owe : owe);
        }

        if (lot == 0) {
            _remove(id);
        } else if (tab == 0) {
            vat.flux(ilk, address(this), usr, lot);
            _remove(id);
        } else {
            sales[id].tab = tab;
            sales[id].lot = lot;
        }

        emit Take(id, max, price, owe, tab, lot, usr);
    }

    function _remove(uint256 id) internal {
        uint256 _move = active[active.length - 1];
        if (id != _move) {
            uint256 _index   = sales[id].pos;
            active[_index]   = _move;
            sales[_move].pos = _index;
        }
        active.pop();
        delete sales[id];
    }

    function count() external view returns (uint256) { return active.length; }
    function list() external view returns (uint256[] memory) { return active; }

    function getStatus(uint256 id) external view returns (bool needsRedo, uint256 price, uint256 lot, uint256 tab) {
        address usr = sales[id].usr;
        bool done;
        (done, price) = status(sales[id].tic, sales[id].top);
        needsRedo = usr != address(0) && done;
        lot = sales[id].lot;
        tab = sales[id].tab;
    }

    function status(uint96 tic, uint256 top) internal view returns (bool done, uint256 price) {
        price = calc.price(top, block.timestamp - tic);
        done  = (block.timestamp - tic > tail || rdiv(price, top) < cusp);
    }

    function upchost() external {
        (,,,, uint256 _dust) = vat.ilks(ilk);
        chost = (_dust * dog.chop(ilk)) / WAD;
        emit Upchost(chost);
    }

    function yank(uint256 id) external auth lock {
        if (sales[id].usr == address(0)) revert NotRunningAuction();
        dog.digs(ilk, sales[id].tab);
        vat.flux(ilk, address(this), msg.sender, sales[id].lot);
        _remove(id);
        emit Yank(id);
    }
}

// ──────────────────────────────────────────────
// PipJoin — with configurable floor (default 0.95)
// ──────────────────────────────────────────────
contract PipJoin {
    event PriceUpdated(uint256 price, bool ok);
    event PriceValidation(uint256 attemptedWad, bool accepted, uint256 minBound, uint256 maxBound);
    event PriceBoundsUpdated(uint256 newMin, uint256 newMax);
    event FloorUpdated(uint256 newFloor);

    struct PriceData {
        uint256 val;
        bool ok;
    }

    ISimpleTWAPOracle public immutable oracle;
    address public immutable token;
    uint8 public immutable dec;

    PriceData public spot;

    address public ward;
    mapping(address => uint256) public bud;

    uint256 public constant WAD = 10 ** 18;
    uint256 public constant INITIAL_PRICE = 1 * WAD;

    uint256 public minPriceWad;
    uint256 public maxPriceWad;

    uint256 public floor;

    constructor(address _oracle, address _token) {
        oracle = ISimpleTWAPOracle(_oracle);
        token = _token;

        uint8 _dec = IERC20(_token).decimals();
        require(_dec <= 18, "PipJoin/unsupported-decimals-gt-18");
        dec = _dec;

        // AUDIT FIX: Changed from 1 to 0.5 WAD. If minPriceWad=1, a 0.949 depeg 
        // fails the inRange check and returns (0, false), breaking the liquidation feed.
        minPriceWad = 5 * 10 ** 17; 
        maxPriceWad = 10 ** 36;

        floor = 95 * 10 ** 16;   // 0.95 * WAD

        ward = msg.sender;
        spot = PriceData(INITIAL_PRICE, false);
        emit PriceUpdated(INITIAL_PRICE, false);
        emit PriceBoundsUpdated(minPriceWad, maxPriceWad);
        emit FloorUpdated(floor);
    }

    modifier auth() { require(msg.sender == ward, "PipJoin/not-authorized"); _; }
    modifier kissed() { require(bud[msg.sender] == 1, "PipJoin/not-whitelisted"); _; }

    function setWard(address newWard) external auth { ward = newWard; }
    function kiss(address who) external auth { bud[who] = 1; }
    function diss(address who) external auth { bud[who] = 0; }

    function setPriceBounds(uint256 newMin, uint256 newMax) external auth {
        require(newMin > 0 && newMax > newMin, "PipJoin/invalid-bounds");
        minPriceWad = newMin;
        maxPriceWad = newMax;
        emit PriceBoundsUpdated(newMin, newMax);
    }

    function setFloor(uint256 newFloor) external auth {
        require(newFloor <= WAD, "PipJoin/floor-cannot-exceed-1");
        floor = newFloor;
        emit FloorUpdated(newFloor);
    }

    function poke() external {
        try this.getPrice() returns (uint256 priceWad, bool success) {
            if (!success && priceWad > 0) {
                emit PriceValidation(priceWad, false, minPriceWad, maxPriceWad);
            }
            if (success) {
                spot = PriceData(priceWad, true);
                emit PriceUpdated(priceWad, true);
            } else {
                spot.ok = false;
                emit PriceUpdated(spot.val, false);
            }
        } catch {
            spot.ok = false;
            emit PriceUpdated(spot.val, false);
        }
    }

    function getPrice() external view returns (uint256 val, bool success) {
        uint256 amountIn = 10 ** uint256(dec);

        try oracle.getPriceInUsd(token, amountIn) returns (uint256 priceForOneToken) {
            if (priceForOneToken == 0) return (0, false);

            uint256 wad = priceForOneToken;

            if (wad < floor) {
                wad = priceForOneToken;        // severe depeg -> report real price
            } else {
                wad = WAD;                     // normal range -> always report exactly 1.0
            }

            bool inRange = (wad >= minPriceWad && wad <= maxPriceWad);
            return (inRange ? wad : 0, inRange);
        } catch {
            return (0, false);
        }
    }

    function peek() external view returns (bytes32, bool) {
        return (bytes32(spot.val), spot.ok);
    }

    function peep() external view kissed returns (bytes32, bool) {
        (uint256 priceWad, bool success) = this.getPrice();
        return success ? (bytes32(priceWad), true) : (bytes32(spot.val), false);
    }

    function read() external view returns (uint256) {
        require(spot.ok, "PipJoin/invalid-price");
        return spot.val;
    }
}

// ──────────────────────────────────────────────
// GemJoin (upgraded to 0.8.20)
// ──────────────────────────────────────────────
contract GemJoin {
    mapping(address => uint256) public wards;
    function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
    function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }
    modifier auth { require(wards[msg.sender] == 1, "GemJoin/not-authorized"); _; }

    VatLike public vat;
    bytes32 public ilk;
    GemLike public gem;
    uint8   public dec;
    uint256 public live;

    event Rely(address indexed usr);
    event Deny(address indexed usr);
    event Join(address indexed usr, uint256 wad);
    event Exit(address indexed usr, uint256 wad);
    event Cage();

    constructor(address vat_, bytes32 ilk_, address gem_) {
        wards[msg.sender] = 1;
        live = 1;
        vat = VatLike(vat_);
        ilk = ilk_;
        gem = GemLike(gem_);
        dec = gem.decimals();
        require(dec <= 18, "GemJoin/unsupported-decimals-gt-18");
        emit Rely(msg.sender);
    }

    function cage() external auth { live = 0; emit Cage(); }

    function join(address usr, uint256 wad) external {
        require(live == 1, "GemJoin/not-live");
        uint256 scaledWad = wad * (10 ** (18 - dec));
        require(scaledWad / (10 ** (18 - dec)) == wad, "GemJoin/overflow-on-scale");
        vat.slip(ilk, usr, int256(scaledWad));
        require(gem.transferFrom(msg.sender, address(this), wad), "GemJoin/failed-transfer");
        emit Join(usr, wad);
    }

    function exit(address usr, uint256 wad) external {
    require(live == 1, "GemJoin/not-live");
    uint256 factor = 10 ** (18 - dec);
    require(wad <= uint256(type(int256).max) / factor, "GemJoin/overflow-on-scale");
    uint256 scaledWad = wad * factor;
    vat.slip(ilk, msg.sender, -int256(scaledWad));
    require(gem.transfer(usr, wad), "GemJoin/failed-transfer");
    emit Exit(usr, wad);
}
}

// ──────────────────────────────────────────────
// DssPsm
// ──────────────────────────────────────────────
contract DssPsm {
    error NotAuthorized();
    error InvalidParam();
    error TransferFailed();
    error SystemCaged();
    error ZeroAmount();

    bytes32  public immutable ilk;
    address  public immutable vat;
    address  public immutable gemJoin;
    GemLike  public immutable gem;
    DaiLike  public immutable dai;
    address  public immutable daiJoin;
    address  public immutable vow;

    uint256 public immutable to18ConversionFactor;

    mapping(address => uint256) public wards;

    uint256 public tin;
    uint256 public tout;

    uint256 public live = 1;

    event Rely(address indexed usr);
    event Deny(address indexed usr);
    event File(bytes32 indexed what, uint256 data);
    event SellGem(address indexed owner, uint256 gemAmt, uint256 fee);
    event BuyGem(address indexed owner, uint256 gemAmt, uint256 fee);
    event Cage();

    modifier auth() {
        if (wards[msg.sender] == 0) revert NotAuthorized();
        _;
    }

    modifier whenLive() {
        if (live == 0) revert SystemCaged();
        _;
    }

    constructor(address _gemJoin, address _daiJoin, address _vow) {
        wards[msg.sender] = 1;
        emit Rely(msg.sender);

        gemJoin = _gemJoin;
        daiJoin = _daiJoin;
        vow     = _vow;

        vat = GemJoinLike(_gemJoin).vat();
        gem = GemLike(GemJoinLike(_gemJoin).gem());
        dai = DaiLike(DaiJoinLike(_daiJoin).dai());
        ilk = GemJoinLike(_gemJoin).ilk();

        uint8 gemDec = GemJoinLike(_gemJoin).dec();
        require(gemDec <= 18, "PSM/gem-decimals-too-high");
        to18ConversionFactor = 10 ** (18 - gemDec);

        require(dai.approve(_daiJoin, type(uint256).max), "PSM/dai-approve-failed");
        require(gem.approve(_gemJoin, type(uint256).max), "PSM/gem-approve-failed");

        VatLike(vat).hope(_daiJoin);
        VatLike(vat).hope(_gemJoin);
        VatLike(vat).hope(address(this));
    }

    function _safeTransferFrom(GemLike token, address from, address to, uint256 wad) internal {
        if (!token.transferFrom(from, to, wad)) revert TransferFailed();
    }

    function _safeTransfer(GemLike token, address to, uint256 wad) internal {
        if (!token.transfer(to, wad)) revert TransferFailed();
    }

    function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
    function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }

    function file(bytes32 what, uint256 data) external auth {
        if      (what == "tin")  tin = data;
        else if (what == "tout") tout = data;
        else revert InvalidParam();
        emit File(what, data);
    }

    function cage() external auth { live = 0; emit Cage(); }

    function hope(address usr) external auth { VatLike(vat).hope(usr); }
    function nope(address usr) external auth { VatLike(vat).nope(usr); }

    function sellGem(address usr, uint256 gemAmt) external whenLive {
        if (gemAmt == 0) revert ZeroAmount();

        uint256 gemAmt18 = gemAmt * to18ConversionFactor;
        uint256 fee      = (gemAmt18 * tin) / 1e18;
        uint256 daiAmt   = gemAmt18 - fee;

        _safeTransferFrom(gem, msg.sender, address(this), gemAmt);
        GemJoinLike(gemJoin).join(address(this), gemAmt);

        VatLike(vat).frob(ilk, address(this), address(this), address(this),
            int256(gemAmt18), int256(gemAmt18));

        VatLike(vat).move(address(this), vow, fee * 1e27);

        DaiJoinLike(daiJoin).exit(usr, daiAmt);

        emit SellGem(usr, gemAmt, fee);
    }

    function buyGem(address usr, uint256 gemAmt) external whenLive {
        if (gemAmt == 0) revert ZeroAmount();

        uint256 gemAmt18 = gemAmt * to18ConversionFactor;
        uint256 fee      = (gemAmt18 * tout) / 1e18;
        uint256 daiAmt   = gemAmt18 + fee;

        _safeTransferFrom(dai, msg.sender, address(this), daiAmt);
        DaiJoinLike(daiJoin).join(address(this), daiAmt);

        VatLike(vat).frob(ilk, address(this), address(this), address(this),
            -int256(gemAmt18), -int256(gemAmt18));

        GemJoinLike(gemJoin).exit(usr, gemAmt);

        VatLike(vat).move(address(this), vow, fee * 1e27);

        emit BuyGem(usr, gemAmt, fee);
    }

    uint256 internal constant WAD = 1e18;
    uint256 internal constant RAY = 1e27;
}

// ──────────────────────────────────────────────
// Deploy PSM Spell (0.8.20) - PRODUCTION OPTIMIZED
// ──────────────────────────────────────────────
contract DeployPsmSpell {

    struct PsmParams {
        address vat;
        address spotter;
        address daiJoin;
        address vow;
        address gem;
        bytes32 ilk;
        address oracle;
        uint256 tin;
        uint256 tout;
        uint256 line;
        address gemJoin;   
        address registry;  
        address dog;        
        address calc;       
        uint256 buf;        
        uint256 tail;       
        uint256 cusp;       
        uint256 hole;       
        uint256 chop;       
        address exec;        // The GovExec contract
    }

    address public immutable vat;
    address public immutable spotter;
    address public immutable daiJoin;
    address public immutable vow;
    bytes32 public immutable ilk;
    address public immutable gem;
    address public immutable oracle;
    uint256 public immutable tin;
    uint256 public immutable tout;
    uint256 public immutable line;
    address public immutable registry;
    address public immutable inputGemJoin;
    
    address public immutable dog;
    address public immutable calc;
    uint256 public immutable buf;
    uint256 public immutable tail;
    uint256 public immutable cusp;
    uint256 public immutable hole;
    uint256 public immutable chop;
    address public immutable exec; 

    address public immutable pip;
    address public immutable psm;
    address public immutable clip;
    address public immutable gemJoin;

    uint256 constant WAD = 10 ** 18;
    uint256 constant RAY = 10 ** 27;

    event SpellExecuted(
        bytes32 indexed ilk, 
        address indexed psm, 
        address indexed clip,
        uint256 line, 
        uint256 tin, 
        uint256 tout
    );

    constructor(PsmParams memory params) {
        require(params.vat != address(0), "DeployPsmSpell/invalid-vat");
        require(params.spotter != address(0), "DeployPsmSpell/invalid-spotter");
        require(params.daiJoin != address(0), "DeployPsmSpell/invalid-daiJoin");
        require(params.vow != address(0), "DeployPsmSpell/invalid-vow");
        require(params.gem != address(0), "DeployPsmSpell/invalid-gem");
        require(params.oracle != address(0), "DeployPsmSpell/invalid-oracle");
        require(params.line > 0, "DeployPsmSpell/invalid-line");
        require(params.dog != address(0), "DeployPsmSpell/invalid-dog");
        require(params.calc != address(0), "DeployPsmSpell/invalid-calc");
        require(params.exec != address(0), "DeployPsmSpell/invalid-exec");

        vat          = params.vat;
        spotter      = params.spotter;
        daiJoin      = params.daiJoin;
        vow          = params.vow;
        ilk          = params.ilk;
        gem          = params.gem;
        oracle       = params.oracle;
        tin          = params.tin;
        tout         = params.tout;
        line         = params.line;
        registry     = params.registry;
        inputGemJoin = params.gemJoin;
        exec         = params.exec; 

        dog  = params.dog;
        calc = params.calc;
        
        buf  = params.buf  == 0 ? 1055 * 10 ** 24 : params.buf; 
        tail = params.tail == 0 ? 6 hours         : params.tail;
        cusp = params.cusp == 0 ? 9 * 10 ** 26    : params.cusp; 
        hole = params.hole; 
        chop = params.chop == 0 ? WAD             : params.chop; 

            // ==========================================
        // PHASE 1: DEPLOY & HANDOFF
        // msg.sender is your wallet. We set GovExec as ward.
        // ==========================================

        // 1. PipJoin
        pip = address(new PipJoin(oracle, gem));
        PipJoin(pip).kiss(spotter);         
        PipJoin(pip).setWard(exec);     // Overwrites single ward variable. Wallet implicitly removed.

        // 2. GemJoin
        if (inputGemJoin == address(0)) {
            gemJoin = address(new GemJoin(vat, ilk, gem));
            GemJoin(gemJoin).rely(exec);     // Add exec to mapping
            GemJoin(gemJoin).deny(msg.sender); // Explicitly remove wallet from mapping
        } else {
            gemJoin = inputGemJoin;
        }

        // 3. PSM
        psm = address(new DssPsm(gemJoin, daiJoin, vow));
        DssPsm(psm).rely(exec);         // Add exec to mapping FIRST
        DssPsm(psm).deny(msg.sender);   // Remove wallet from mapping SECOND

        // 4. Clipper
        clip = address(new Clipper(vat, spotter, dog, ilk));
        Clipper(clip).rely(exec);       // Add exec to mapping FIRST
        Clipper(clip).deny(msg.sender); // Remove wallet from mapping SECOND
    }

    // ==========================================
    // PHASE 2: CONFIGURATION 
    // Runs via GovExec.delegatecall(). 
    // msg.sender seen by Vat/Spotter/Dog is GovExec.
    // ==========================================
    function execute() external {

        // 1. Spotter Config
        SpotterLike(spotter).rely(pip);
        SpotterLike(spotter).file(ilk, "pip", pip);
        SpotterLike(spotter).file(ilk, "mat", RAY);
        PipJoin(pip).poke();
        SpotterLike(spotter).poke(ilk);

        // 2. Vat Config
        if (inputGemJoin == address(0)) {
            VatLike(vat).init(ilk);       // <--- ADD IT HERE
            VatLike(vat).rely(gemJoin); 
        }
        VatLike(vat).file(ilk, "line", line);
        VatLike(vat).file(ilk, "dust", 0);

        // 3. PSM Config
        DssPsm(psm).file("tin", tin);
        DssPsm(psm).file("tout", tout);
        DssPsm(psm).hope(clip); 

        // 4. Clipper & Dog Config
        VatLike(vat).rely(clip);
        DogLike(dog).rely(clip);
        
        Clipper(clip).file("vow", vow);
        Clipper(clip).file("calc", calc);
        Clipper(clip).file("buf", buf);
        Clipper(clip).file("tail", tail);
        Clipper(clip).file("cusp", cusp);
        Clipper(clip).file("tip", 0);
        Clipper(clip).file("chip", 0);
       
        
        DogLike(dog).file(ilk, "clip", clip);
        DogLike(dog).file(ilk, "chop", chop);
        DogLike(dog).file(ilk, "hole", hole);

        Clipper(clip).upchost();

        // 5. Registry
        if (registry != address(0)) {
            PaiRegistryLike(registry).addIlk(ilk, gem, gemJoin, pip, clip, address(0), psm);
        }

        emit SpellExecuted(ilk, psm, clip, line, tin, tout);
    }


    // ──────────────────────────────────────────────
    // Helpers
    // ──────────────────────────────────────────────
    function bytes32ToString(bytes32 _bytes32) internal pure returns (string memory) {
        bytes memory bytesArray = new bytes(32);
        uint256 len = 0;
        for (uint256 i = 0; i < 32; i++) {
            bytes1 b = _bytes32[i];
            if (b == 0x00) break;
            bytesArray[len] = b;
            len++;
        }
        bytes memory trimmed = new bytes(len);
        for (uint256 i = 0; i < len; i++) trimmed[i] = bytesArray[i];
        return string(trimmed);
    }

    function uintToString(uint256 _i) internal pure returns (string memory) {
        if (_i == 0) return "0";
        uint256 j = _i;
        uint256 len;
        while (j != 0) { len++; j /= 10; }
        bytes memory bstr = new bytes(len);
        uint256 k = len - 1;
        while (_i != 0) {
            bstr[k--] = bytes1(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }
}