Set Protocol

1pragma solidity 0.6.10;
2pragma experimental "ABIEncoderV2";
3
4import { Address } from "@openzeppelin/contracts/utils/Address.sol";
5import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
6import { SafeCast } from "@openzeppelin/contracts/utils/SafeCast.sol";
7import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
8import { SignedSafeMath } from "@openzeppelin/contracts/math/SignedSafeMath.sol";
9
10import { IController } from "../interfaces/IController.sol";
11import { IModule } from "../interfaces/IModule.sol";
12import { ISetToken } from "../interfaces/ISetToken.sol";
13import { Position } from "./lib/Position.sol";
14import { PreciseUnitMath } from "../lib/PreciseUnitMath.sol";
15import { AddressArrayUtils } from "../lib/AddressArrayUtils.sol";
16
17
18/**
19 * @title SetToken
20 * @author Set Protocol
21 *
22 * ERC20 Token contract that allows privileged modules to make modifications to its positions and invoke function calls
23 * from the SetToken. 
24 */
25contract SetToken is ERC20 {
26    using SafeMath for uint256;
27    using SafeCast for int256;
28    using SafeCast for uint256;
29    using SignedSafeMath for int256;
30    using PreciseUnitMath for int256;
31    using Address for address;
32    using AddressArrayUtils for address[];
33
34    /* ============ Constants ============ */
35
36    /*
37        The PositionState is the status of the Position, whether it is Default (held on the SetToken)
38        or otherwise held on a separate smart contract (whether a module or external source).
39        There are issues with cross-usage of enums, so we are defining position states
40        as a uint8.
41    */
42    uint8 internal constant DEFAULT = 0;
43    uint8 internal constant EXTERNAL = 1;
44
45    /* ============ Events ============ */
46
47    event Invoked(address indexed _target, uint indexed _value, bytes _data, bytes _returnValue);
48    event ModuleAdded(address indexed _module);
49    event ModuleRemoved(address indexed _module);    
50    event ModuleInitialized(address indexed _module);
51    event ManagerEdited(address _newManager, address _oldManager);
52    event PendingModuleRemoved(address indexed _module);
53    event PositionMultiplierEdited(int256 _newMultiplier);
54    event ComponentAdded(address indexed _component);
55    event ComponentRemoved(address indexed _component);
56    event DefaultPositionUnitEdited(address indexed _component, int256 _realUnit);
57    event ExternalPositionUnitEdited(address indexed _component, address indexed _positionModule, int256 _realUnit);
58    event ExternalPositionDataEdited(address indexed _component, address indexed _positionModule, bytes _data);
59    event PositionModuleAdded(address indexed _component, address indexed _positionModule);
60    event PositionModuleRemoved(address indexed _component, address indexed _positionModule);
61
62    /* ============ Modifiers ============ */
63
64    /**
65     * Throws if the sender is not a SetToken's module or module not enabled
66     */
67    modifier onlyModule() {
68        // Internal function used to reduce bytecode size
69        _validateOnlyModule();
70        _;
71    }
72
73    /**
74     * Throws if the sender is not the SetToken's manager
75     */
76    modifier onlyManager() {
77        _validateOnlyManager();
78        _;
79    }
80
81    /**
82     * Throws if SetToken is locked and called by any account other than the locker.
83     */
84    modifier whenLockedOnlyLocker() {
85        _validateWhenLockedOnlyLocker();
86        _;
87    }
88
89    /* ============ State Variables ============ */
90
91    // Address of the controller
92    IController public controller;
93
94    // The manager has the privelege to add modules, remove, and set a new manager
95    address public manager;
96
97    // A module that has locked other modules from privileged functionality, typically required
98    // for multi-block module actions such as auctions
99    address public locker;
100
101    // List of initialized Modules; Modules extend the functionality of SetTokens
102    address[] public modules;
103
104    // Modules are initialized from NONE -> PENDING -> INITIALIZED through the
105    // addModule (called by manager) and initialize  (called by module) functions
106    mapping(address => ISetToken.ModuleState) public moduleStates;
107
108    // When locked, only the locker (a module) can call privileged functionality
109    // Typically utilized if a module (e.g. Auction) needs multiple transactions to complete an action
110    // without interruption
111    bool public isLocked;
112
113    // List of components
114    address[] public components;
115
116    // Mapping that stores all Default and External position information for a given component.
117    // Position quantities are represented as virtual units; Default positions are on the top-level,
118    // while external positions are stored in a module array and accessed through its externalPositions mapping
119    mapping(address => ISetToken.ComponentPosition) private componentPositions;
120
121    // The multiplier applied to the virtual position unit to achieve the real/actual unit.
122    // This multiplier is used for efficiently modifying the entire position units (e.g. streaming fee)
123    int256 public positionMultiplier;
124
125    /* ============ Constructor ============ */
126
127    /**
128     * When a new SetToken is created, initializes Positions in default state and adds modules into pending state.
129     * All parameter validations are on the SetTokenCreator contract. Validations are performed already on the 
130     * SetTokenCreator. Initiates the positionMultiplier as 1e18 (no adjustments).
131     *
132     * @param _components             List of addresses of components for initial Positions
133     * @param _units                  List of units. Each unit is the # of components per 10^18 of a SetToken
134     * @param _modules                List of modules to enable. All modules must be approved by the Controller
135     * @param _controller             Address of the controller
136     * @param _manager                Address of the manager
137     * @param _name                   Name of the SetToken
138     * @param _symbol                 Symbol of the SetToken
139     */
140    constructor(
141        address[] memory _components,
142        int256[] memory _units,
143        address[] memory _modules,
144        IController _controller,
145        address _manager,
146        string memory _name,
147        string memory _symbol
148    )
149        public
150        ERC20(_name, _symbol)
151    {
152        controller = _controller;
153        manager = _manager;
154        positionMultiplier = PreciseUnitMath.preciseUnitInt();
155        components = _components;
156
157        // Modules are put in PENDING state, as they need to be individually initialized by the Module
158        for (uint256 i = 0; i < _modules.length; i++) {
159            moduleStates[_modules[i]] = ISetToken.ModuleState.PENDING;
160        }
161
162        // Positions are put in default state initially
163        for (uint256 j = 0; j < _components.length; j++) {
164            componentPositions[_components[j]].virtualUnit = _units[j];
165        }
166    }
167
168    /* ============ External Functions ============ */
169
170    /**
171     * PRIVELEGED MODULE FUNCTION. Low level function that allows a module to make an arbitrary function
172     * call to any contract.
173     *
174     * @param _target                 Address of the smart contract to call
175     * @param _value                  Quantity of Ether to provide the call (typically 0)
176     * @param _data                   Encoded function selector and arguments
177     * @return _returnValue           Bytes encoded return value
178     */
179    function invoke(
180        address _target,
181        uint256 _value,
182        bytes calldata _data
183    )
184        external
185        onlyModule
186        whenLockedOnlyLocker
187        returns (bytes memory _returnValue)
188    {
189        _returnValue = _target.functionCallWithValue(_data, _value);
190
191        emit Invoked(_target, _value, _data, _returnValue);
192
193        return _returnValue;
194    }
195
196    /**
197     * PRIVELEGED MODULE FUNCTION. Low level function that adds a component to the components array.
198     */
199    function addComponent(address _component) external onlyModule whenLockedOnlyLocker {
200        require(!isComponent(_component), "Must not be component");
201        
202        components.push(_component);
203
204        emit ComponentAdded(_component);
205    }
206

JavaScript Tests