Ampleforth

1/**
2 * @title Orchestrator
3 * @notice The orchestrator is the main entry point for rebase operations. It coordinates the policy
4 * actions with external consumers.
5 */
6contract Orchestrator is Ownable {
7    struct Transaction {
8        bool enabled;
9        address destination;
10        bytes data;
11    }
12​
13    // Stable ordering is not guaranteed.
14    Transaction[] public transactions;
15​
16    UFragmentsPolicy public policy;
17​
18    /**
19     * @param policy_ Address of the UFragments policy.
20     */
21    constructor(address policy_) public {
22        Ownable.initialize(msg.sender);
23        policy = UFragmentsPolicy(policy_);
24    }
25​
26    /**
27     * @notice Main entry point to initiate a rebase operation.
28     *         The Orchestrator calls rebase on the policy and notifies downstream applications.
29     *         Contracts are guarded from calling, to avoid flash loan attacks on liquidity
30     *         providers.
31     *         If a transaction in the transaction list fails, Orchestrator will stop execution
32     *         and revert to prevent a gas underprice attack.
33     */
34    function rebase() external {
35        require(msg.sender == tx.origin); // solhint-disable-line avoid-tx-origin
36​
37        policy.rebase();
38​
39        for (uint256 i = 0; i < transactions.length; i++) {
40            Transaction storage t = transactions[i];
41            if (t.enabled) {
42                (bool result, ) = t.destination.call(t.data);
43                if (!result) {
44                    revert("Transaction Failed");
45                }
46            }
47        }
48    }
49​
50    /**
51     * @notice Adds a transaction that gets called for a downstream receiver of rebases
52     * @param destination Address of contract destination
53     * @param data Transaction data payload
54     */
55    function addTransaction(address destination, bytes memory data) external onlyOwner {
56        transactions.push(Transaction({enabled: true, destination: destination, data: data}));
57    }
58​
59    /**
60     * @param index Index of transaction to remove.
61     *              Transaction ordering may have changed since adding.
62     */
63    function removeTransaction(uint256 index) external onlyOwner {
64        require(index < transactions.length, "index out of bounds");
65​
66        if (index < transactions.length - 1) {
67            transactions[index] = transactions[transactions.length - 1];
68        }
69​
70        transactions.pop();
71    }
72​
73    /*
74     * @param index Index of transaction. Transaction ordering may have changed since adding.
75     * @param enabled True for enabled, false for disabled.
76     */
77    function setTransactionEnabled(uint256 index, bool enabled) external onlyOwner {
78        require(index < transactions.length, "index must be in range of stored tx list");
79        transactions[index].enabled = enabled;
80    }
81​
82    /*
83     * @return Number of transactions, both enabled and disabled, in transactions list.
84     */
85    function transactionsSize() external view returns (uint256) {
86        return transactions.length;
87    }
88}

Solidity Contracts

JavaScript Tests