MakerDAO

1pragma solidity >=0.6.12;
2​
3interface VatLike {
4    function move(address,address,uint256) external;
5    function flux(bytes32,address,address,uint256) external;
6    function ilks(bytes32) external returns (uint256, uint256, uint256, uint256, uint256);
7    function suck(address,address,uint256) external;
8}
9​
10interface PipLike {
11    function peek() external returns (bytes32, bool);
12}
13​
14interface SpotterLike {
15    function par() external returns (uint256);
16    function ilks(bytes32) external returns (PipLike, uint256);
17}
18​
19interface DogLike {
20    function chop(bytes32) external returns (uint256);
21    function digs(bytes32, uint256) external;
22}
23​
24interface ClipperCallee {
25    function clipperCall(address, uint256, uint256, bytes calldata) external;
26}
27​
28interface AbacusLike {
29    function price(uint256, uint256) external view returns (uint256);
30}
31​
32contract Clipper {
33    // --- Auth ---
34    mapping (address => uint256) public wards;
35    function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
36    function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }
37    modifier auth {
38        require(wards[msg.sender] == 1, "Clipper/not-authorized");
39        _;
40    }
41​
42    // --- Data ---
43    bytes32  immutable public ilk;   // Collateral type of this Clipper
44    VatLike  immutable public vat;   // Core CDP Engine
45​
46    DogLike     public dog;      // Liquidation module
47    address     public vow;      // Recipient of dai raised in auctions
48    SpotterLike public spotter;  // Collateral price module
49    AbacusLike  public calc;     // Current price calculator
50​
51    uint256 public buf;    // Multiplicative factor to increase starting price                  [ray]
52    uint256 public tail;   // Time elapsed before auction reset                                 [seconds]
53    uint256 public cusp;   // Percentage drop before auction reset                              [ray]
54    uint64  public chip;   // Percentage of tab to suck from vow to incentivize keepers         [wad]
55    uint192 public tip;    // Flat fee to suck from vow to incentivize keepers                  [rad]
56    uint256 public chost;  // Cache the ilk dust times the ilk chop to prevent excessive SLOADs [rad]
57​
58    uint256   public kicks;   // Total auctions
59    uint256[] public active;  // Array of active auction ids
60​
61    struct Sale {
62        uint256 pos;  // Index in active array
63        uint256 tab;  // Dai to raise       [rad]
64        uint256 lot;  // collateral to sell [wad]
65        address usr;  // Liquidated CDP
66        uint96  tic;  // Auction start time
67        uint256 top;  // Starting price     [ray]
68    }
69    mapping(uint256 => Sale) public sales;
70​
71    uint256 internal locked;
72​
73    // Levels for circuit breaker
74    // 0: no breaker
75    // 1: no new kick()
76    // 2: no new kick() or redo()
77    // 3: no new kick(), redo(), or take()
78    uint256 public stopped = 0;
79​
80    // --- Events ---
81    event Rely(address indexed usr);
82    event Deny(address indexed usr);
83​
84    event File(bytes32 indexed what, uint256 data);
85    event File(bytes32 indexed what, address data);
86​
87    event Kick(
88        uint256 indexed id,
89        uint256 top,
90        uint256 tab,
91        uint256 lot,
92        address indexed usr,
93        address indexed kpr,
94        uint256 coin
95    );
96    event Take(
97        uint256 indexed id,
98        uint256 max,
99        uint256 price,
100        uint256 owe,
101        uint256 tab,
102        uint256 lot,
103        address indexed usr
104    );
105    event Redo(
106        uint256 indexed id,
107        uint256 top,
108        uint256 tab,
109        uint256 lot,
110        address indexed usr,
111        address indexed kpr,
112        uint256 coin
113    );
114​
115    event Yank(uint256 id);
116​
117    // --- Init ---
118    constructor(address vat_, address spotter_, address dog_, bytes32 ilk_) public {
119        vat     = VatLike(vat_);
120        spotter = SpotterLike(spotter_);
121        dog     = DogLike(dog_);
122        ilk     = ilk_;
123        buf     = RAY;
124        wards[msg.sender] = 1;
125        emit Rely(msg.sender);
126    }
127​
128    // --- Synchronization ---
129    modifier lock {
130        require(locked == 0, "Clipper/system-locked");
131        locked = 1;
132        _;
133        locked = 0;
134    }
135​
136    modifier isStopped(uint256 level) {
137        require(stopped < level, "Clipper/stopped-incorrect");
138        _;
139    }
140​
141    // --- Administration ---
142    function file(bytes32 what, uint256 data) external auth lock {
143        if      (what == "buf")         buf = data;
144        else if (what == "tail")       tail = data;           // Time elapsed before auction reset
145        else if (what == "cusp")       cusp = data;           // Percentage drop before auction reset
146        else if (what == "chip")       chip = uint64(data);   // Percentage of tab to incentivize (max: 2^64 - 1 => 18.xxx WAD = 18xx%)
147        else if (what == "tip")         tip = uint192(data);  // Flat fee to incentivize keepers (max: 2^192 - 1 => 6.277T RAD)
148        else if (what == "stopped") stopped = data;           // Set breaker (0, 1, 2, or 3)
149        else revert("Clipper/file-unrecognized-param");
150        emit File(what, data);
151    }
152    function file(bytes32 what, address data) external auth lock {
153        if (what == "spotter") spotter = SpotterLike(data);
154        else if (what == "dog")    dog = DogLike(data);
155        else if (what == "vow")    vow = data;
156        else if (what == "calc")  calc = AbacusLike(data);
157        else revert("Clipper/file-unrecognized-param");
158        emit File(what, data);
159    }
160​
161    // --- Math ---
162    uint256 constant BLN = 10 **  9;
163    uint256 constant WAD = 10 ** 18;
164    uint256 constant RAY = 10 ** 27;
165​
166    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
167        z = x <= y ? x : y;
168    }
169    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
170        require((z = x + y) >= x);
171    }
172    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
173        require((z = x - y) <= x);
174    }
175    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
176        require(y == 0 || (z = x * y) / y == x);
177    }
178    function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
179        z = mul(x, y) / WAD;
180    }
181    function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
182        z = mul(x, y) / RAY;
183    }
184    function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
185        z = mul(x, RAY) / y;
186    }
187​
188    // --- Auction ---
189​
190    // get the price directly from the OSM
191    // Could get this from rmul(Vat.ilks(ilk).spot, Spotter.mat()) instead, but
192    // if mat has changed since the last poke, the resulting value will be
193    // incorrect.
194    function getFeedPrice() internal returns (uint256 feedPrice) {
195        (PipLike pip, ) = spotter.ilks(ilk);
196        (bytes32 val, bool has) = pip.peek();
197        require(has, "Clipper/invalid-price");
198        feedPrice = rdiv(mul(uint256(val), BLN), spotter.par());
199    }
200​
201    // start an auction
202    // note: trusts the caller to transfer collateral to the contract
203    // The starting price `top` is obtained as follows:
204    //
205    //     top = val * buf / par
206    //
207    // Where `val` is the collateral's unitary value in USD, `buf` is a
208    // multiplicative factor to increase the starting price, and `par` is a
209    // reference per DAI.
210    function kick(
211        uint256 tab,  // Debt                   [rad]
212        uint256 lot,  // Collateral             [wad]
213        address usr,  // Address that will receive any leftover collateral
214        address kpr   // Address that will receive incentives
215    ) external auth lock isStopped(1) returns (uint256 id) {
216        / Input validation
217        require(tab  >          0, "Clipper/zero-tab");
218        require(lot  >          0, "Clipper/zero-lot");
219        require(usr != address(0), "Clipper/zero-usr");
220        id = ++kicks;
221        require(id   >          0, "Clipper/overflow");
222​
223        active.push(id);
224​
225        sales[id].pos = active.length - 1;
226​
227        sales[id].tab = tab;
228        sales[id].lot = lot;
229        sales[id].usr = usr;
230        sales[id].tic = uint96(block.timestamp);
231​
232        uint256 top;
233        top = rmul(getFeedPrice(), buf);
234        require(top > 0, "Clipper/zero-top-price");
235        sales[id].top = top;
236​
237        / incentive to kick auction
238        uint256 _tip  = tip;
239        uint256 _chip = chip;
240        uint256 coin;
241        if (_tip > 0 || _chip > 0) {
242            coin = add(_tip, wmul(tab, _chip));
243            vat.suck(vow, kpr, coin);
244        }
245​

Solidity Contracts

JavaScript Tests