File 1 of 1: SetToken.sol
pragma solidity >=0.6.2 <0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity >=0.6.0 <0.8.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
pragma solidity >=0.6.0 <0.8.0;
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
pragma solidity >=0.6.0 <0.8.0;
library SafeCast {
function toUint128(uint256 value) internal pure returns (uint128) {
require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
return uint128(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
return uint64(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
return uint32(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt128(int256 value) internal pure returns (int128) {
require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits");
return int128(value);
}
function toInt64(int256 value) internal pure returns (int64) {
require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits");
return int64(value);
}
function toInt32(int256 value) internal pure returns (int32) {
require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits");
return int32(value);
}
function toInt16(int256 value) internal pure returns (int16) {
require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits");
return int16(value);
}
function toInt8(int256 value) internal pure returns (int8) {
require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits");
return int8(value);
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value < 2**255, "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
pragma solidity >=0.6.0 <0.8.0;
library SignedSafeMath {
int256 constant private _INT256_MIN = -2**255;
function mul(int256 a, int256 b) internal pure returns (int256) {
if (a == 0) {
return 0;
}
require(!(a == -1 && b == _INT256_MIN), "SignedSafeMath: multiplication overflow");
int256 c = a * b;
require(c / a == b, "SignedSafeMath: multiplication overflow");
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0, "SignedSafeMath: division by zero");
require(!(b == -1 && a == _INT256_MIN), "SignedSafeMath: division overflow");
int256 c = a / b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a), "SignedSafeMath: subtraction overflow");
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a), "SignedSafeMath: addition overflow");
return c;
}
}
pragma solidity 0.6.10;
interface IController {
function addSet(address _setToken) external;
function feeRecipient() external view returns(address);
function getModuleFee(address _module, uint256 _feeType) external view returns(uint256);
function isModule(address _module) external view returns(bool);
function isSet(address _setToken) external view returns(bool);
function isSystemContract(address _contractAddress) external view returns (bool);
function resourceId(uint256 _id) external view returns(address);
}
pragma solidity 0.6.10;
interface IModule {
function removeModule() external;
}
pragma solidity 0.6.10;
interface ISetToken is IERC20 {
enum ModuleState {
NONE,
PENDING,
INITIALIZED
}
struct Position {
address component;
address module;
int256 unit;
uint8 positionState;
bytes data;
}
struct ComponentPosition {
int256 virtualUnit;
address[] externalPositionModules;
mapping(address => ExternalPosition) externalPositions;
}
struct ExternalPosition {
int256 virtualUnit;
bytes data;
}
function addComponent(address _component) external;
function removeComponent(address _component) external;
function editDefaultPositionUnit(address _component, int256 _realUnit) external;
function addExternalPositionModule(address _component, address _positionModule) external;
function removeExternalPositionModule(address _component, address _positionModule) external;
function editExternalPositionUnit(address _component, address _positionModule, int256 _realUnit) external;
function editExternalPositionData(address _component, address _positionModule, bytes calldata _data) external;
function invoke(address _target, uint256 _value, bytes calldata _data) external returns(bytes memory);
function editPositionMultiplier(int256 _newMultiplier) external;
function mint(address _account, uint256 _quantity) external;
function burn(address _account, uint256 _quantity) external;
function lock() external;
function unlock() external;
function addModule(address _module) external;
function removeModule(address _module) external;
function initializeModule() external;
function setManager(address _manager) external;
function manager() external view returns (address);
function moduleStates(address _module) external view returns (ModuleState);
function getModules() external view returns (address[] memory);
function getDefaultPositionRealUnit(address _component) external view returns(int256);
function getExternalPositionRealUnit(address _component, address _positionModule) external view returns(int256);
function getComponents() external view returns(address[] memory);
function getExternalPositionModules(address _component) external view returns(address[] memory);
function getExternalPositionData(address _component, address _positionModule) external view returns(bytes memory);
function isExternalPositionModule(address _component, address _module) external view returns(bool);
function isComponent(address _component) external view returns(bool);
function positionMultiplier() external view returns (int256);
function getPositions() external view returns (Position[] memory);
function getTotalComponentRealUnits(address _component) external view returns(int256);
function isInitializedModule(address _module) external view returns(bool);
function isPendingModule(address _module) external view returns(bool);
function isLocked() external view returns (bool);
}
pragma solidity 0.6.10;
pragma experimental ABIEncoderV2;
library PreciseUnitMath {
using SafeMath for uint256;
using SignedSafeMath for int256;
uint256 constant internal PRECISE_UNIT = 10 ** 18;
int256 constant internal PRECISE_UNIT_INT = 10 ** 18;
uint256 constant internal MAX_UINT_256 = type(uint256).max;
int256 constant internal MAX_INT_256 = type(int256).max;
int256 constant internal MIN_INT_256 = type(int256).min;
function preciseUnit() internal pure returns (uint256) {
return PRECISE_UNIT;
}
function preciseUnitInt() internal pure returns (int256) {
return PRECISE_UNIT_INT;
}
function maxUint256() internal pure returns (uint256) {
return MAX_UINT_256;
}
function maxInt256() internal pure returns (int256) {
return MAX_INT_256;
}
function minInt256() internal pure returns (int256) {
return MIN_INT_256;
}
function preciseMul(uint256 a, uint256 b) internal pure returns (uint256) {
return a.mul(b).div(PRECISE_UNIT);
}
function preciseMul(int256 a, int256 b) internal pure returns (int256) {
return a.mul(b).div(PRECISE_UNIT_INT);
}
function preciseMulCeil(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
return a.mul(b).sub(1).div(PRECISE_UNIT).add(1);
}
function preciseDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a.mul(PRECISE_UNIT).div(b);
}
function preciseDiv(int256 a, int256 b) internal pure returns (int256) {
return a.mul(PRECISE_UNIT_INT).div(b);
}
function preciseDivCeil(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "Cant divide by 0");
return a > 0 ? a.mul(PRECISE_UNIT).sub(1).div(b).add(1) : 0;
}
function divDown(int256 a, int256 b) internal pure returns (int256) {
require(b != 0, "Cant divide by 0");
require(a != MIN_INT_256 || b != -1, "Invalid input");
int256 result = a.div(b);
if (a ^ b < 0 && a % b != 0) {
result -= 1;
}
return result;
}
function conservativePreciseMul(int256 a, int256 b) internal pure returns (int256) {
return divDown(a.mul(b), PRECISE_UNIT_INT);
}
function conservativePreciseDiv(int256 a, int256 b) internal pure returns (int256) {
return divDown(a.mul(PRECISE_UNIT_INT), b);
}
function safePower(
uint256 a,
uint256 pow
)
internal
pure
returns (uint256)
{
require(a > 0, "Value must be positive");
uint256 result = 1;
for (uint256 i = 0; i < pow; i++){
uint256 previousResult = result;
result = previousResult.mul(a);
}
return result;
}
function approximatelyEquals(uint256 a, uint256 b, uint256 range) internal pure returns (bool) {
return a <= b.add(range) && a >= b.sub(range);
}
}
pragma solidity 0.6.10;
library Position {
using SafeCast for uint256;
using SafeMath for uint256;
using SafeCast for int256;
using SignedSafeMath for int256;
using PreciseUnitMath for uint256;
function hasDefaultPosition(ISetToken _setToken, address _component) internal view returns(bool) {
return _setToken.getDefaultPositionRealUnit(_component) > 0;
}
function hasExternalPosition(ISetToken _setToken, address _component) internal view returns(bool) {
return _setToken.getExternalPositionModules(_component).length > 0;
}
function hasSufficientDefaultUnits(ISetToken _setToken, address _component, uint256 _unit) internal view returns(bool) {
return _setToken.getDefaultPositionRealUnit(_component) >= _unit.toInt256();
}
function hasSufficientExternalUnits(
ISetToken _setToken,
address _component,
address _positionModule,
uint256 _unit
)
internal
view
returns(bool)
{
return _setToken.getExternalPositionRealUnit(_component, _positionModule) >= _unit.toInt256();
}
function editDefaultPosition(ISetToken _setToken, address _component, uint256 _newUnit) internal {
bool isPositionFound = hasDefaultPosition(_setToken, _component);
if (!isPositionFound && _newUnit > 0) {
if (!hasExternalPosition(_setToken, _component)) {
_setToken.addComponent(_component);
}
} else if (isPositionFound && _newUnit == 0) {
if (!hasExternalPosition(_setToken, _component)) {
_setToken.removeComponent(_component);
}
}
_setToken.editDefaultPositionUnit(_component, _newUnit.toInt256());
}
function editExternalPosition(
ISetToken _setToken,
address _component,
address _module,
int256 _newUnit,
bytes memory _data
)
internal
{
if (_newUnit != 0) {
if (!_setToken.isComponent(_component)) {
_setToken.addComponent(_component);
_setToken.addExternalPositionModule(_component, _module);
} else if (!_setToken.isExternalPositionModule(_component, _module)) {
_setToken.addExternalPositionModule(_component, _module);
}
_setToken.editExternalPositionUnit(_component, _module, _newUnit);
_setToken.editExternalPositionData(_component, _module, _data);
} else {
require(_data.length == 0, "Passed data must be null");
if (_setToken.getExternalPositionRealUnit(_component, _module) != 0) {
address[] memory positionModules = _setToken.getExternalPositionModules(_component);
if (_setToken.getDefaultPositionRealUnit(_component) == 0 && positionModules.length == 1) {
require(positionModules[0] == _module, "External positions must be 0 to remove component");
_setToken.removeComponent(_component);
}
_setToken.removeExternalPositionModule(_component, _module);
}
}
}
function getDefaultTotalNotional(uint256 _setTokenSupply, uint256 _positionUnit) internal pure returns (uint256) {
return _setTokenSupply.preciseMul(_positionUnit);
}
function getDefaultPositionUnit(uint256 _setTokenSupply, uint256 _totalNotional) internal pure returns (uint256) {
return _totalNotional.preciseDiv(_setTokenSupply);
}
function getDefaultTrackedBalance(ISetToken _setToken, address _component) internal view returns(uint256) {
int256 positionUnit = _setToken.getDefaultPositionRealUnit(_component);
return _setToken.totalSupply().preciseMul(positionUnit.toUint256());
}
function calculateAndEditDefaultPosition(
ISetToken _setToken,
address _component,
uint256 _setTotalSupply,
uint256 _componentPreviousBalance
)
internal
returns(uint256, uint256, uint256)
{
uint256 currentBalance = IERC20(_component).balanceOf(address(_setToken));
uint256 positionUnit = _setToken.getDefaultPositionRealUnit(_component).toUint256();
uint256 newTokenUnit;
if (currentBalance > 0) {
newTokenUnit = calculateDefaultEditPositionUnit(
_setTotalSupply,
_componentPreviousBalance,
currentBalance,
positionUnit
);
} else {
newTokenUnit = 0;
}
editDefaultPosition(_setToken, _component, newTokenUnit);
return (currentBalance, positionUnit, newTokenUnit);
}
function calculateDefaultEditPositionUnit(
uint256 _setTokenSupply,
uint256 _preTotalNotional,
uint256 _postTotalNotional,
uint256 _prePositionUnit
)
internal
pure
returns (uint256)
{
uint256 airdroppedAmount = _preTotalNotional.sub(_prePositionUnit.preciseMul(_setTokenSupply));
return _postTotalNotional.sub(airdroppedAmount).preciseDiv(_setTokenSupply);
}
}
pragma solidity 0.6.10;
library AddressArrayUtils {
function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) {
uint256 length = A.length;
for (uint256 i = 0; i < length; i++) {
if (A[i] == a) {
return (i, true);
}
}
return (uint256(-1), false);
}
function contains(address[] memory A, address a) internal pure returns (bool) {
(, bool isIn) = indexOf(A, a);
return isIn;
}
function hasDuplicate(address[] memory A) internal pure returns(bool) {
require(A.length > 0, "A is empty");
for (uint256 i = 0; i < A.length - 1; i++) {
address current = A[i];
for (uint256 j = i + 1; j < A.length; j++) {
if (current == A[j]) {
return true;
}
}
}
return false;
}
function remove(address[] memory A, address a)
internal
pure
returns (address[] memory)
{
(uint256 index, bool isIn) = indexOf(A, a);
if (!isIn) {
revert("Address not in array.");
} else {
(address[] memory _A,) = pop(A, index);
return _A;
}
}
function removeStorage(address[] storage A, address a)
internal
{
(uint256 index, bool isIn) = indexOf(A, a);
if (!isIn) {
revert("Address not in array.");
} else {
uint256 lastIndex = A.length - 1;
if (index != lastIndex) { A[index] = A[lastIndex]; }
A.pop();
}
}
function pop(address[] memory A, uint256 index)
internal
pure
returns (address[] memory, address)
{
uint256 length = A.length;
require(index < A.length, "Index must be < A length");
address[] memory newAddresses = new address[](length - 1);
for (uint256 i = 0; i < index; i++) {
newAddresses[i] = A[i];
}
for (uint256 j = index + 1; j < length; j++) {
newAddresses[j - 1] = A[j];
}
return (newAddresses, A[index]);
}
function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) {
uint256 aLength = A.length;
uint256 bLength = B.length;
address[] memory newAddresses = new address[](aLength + bLength);
for (uint256 i = 0; i < aLength; i++) {
newAddresses[i] = A[i];
}
for (uint256 j = 0; j < bLength; j++) {
newAddresses[aLength + j] = B[j];
}
return newAddresses;
}
function validatePairsWithArray(address[] memory A, uint[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function validatePairsWithArray(address[] memory A, bool[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function validatePairsWithArray(address[] memory A, string[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function validatePairsWithArray(address[] memory A, address[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function validatePairsWithArray(address[] memory A, bytes[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function _validateLengthAndUniqueness(address[] memory A) internal pure {
require(A.length > 0, "Array length must be > 0");
require(!hasDuplicate(A), "Cannot duplicate addresses");
}
}
pragma solidity 0.6.10;
contract SetToken is ERC20 {
using SafeMath for uint256;
using SafeCast for int256;
using SafeCast for uint256;
using SignedSafeMath for int256;
using PreciseUnitMath for int256;
using Address for address;
using AddressArrayUtils for address[];
uint8 internal constant DEFAULT = 0;
uint8 internal constant EXTERNAL = 1;
event Invoked(address indexed _target, uint indexed _value, bytes _data, bytes _returnValue);
event ModuleAdded(address indexed _module);
event ModuleRemoved(address indexed _module);
event ModuleInitialized(address indexed _module);
event ManagerEdited(address _newManager, address _oldManager);
event PendingModuleRemoved(address indexed _module);
event PositionMultiplierEdited(int256 _newMultiplier);
event ComponentAdded(address indexed _component);
event ComponentRemoved(address indexed _component);
event DefaultPositionUnitEdited(address indexed _component, int256 _realUnit);
event ExternalPositionUnitEdited(address indexed _component, address indexed _positionModule, int256 _realUnit);
event ExternalPositionDataEdited(address indexed _component, address indexed _positionModule, bytes _data);
event PositionModuleAdded(address indexed _component, address indexed _positionModule);
event PositionModuleRemoved(address indexed _component, address indexed _positionModule);
modifier onlyModule() {
_validateOnlyModule();
_;
}
modifier onlyManager() {
_validateOnlyManager();
_;
}
modifier whenLockedOnlyLocker() {
_validateWhenLockedOnlyLocker();
_;
}
IController public controller;
address public manager;
address public locker;
address[] public modules;
mapping(address => ISetToken.ModuleState) public moduleStates;
bool public isLocked;
address[] public components;
mapping(address => ISetToken.ComponentPosition) private componentPositions;
int256 public positionMultiplier;
constructor(
address[] memory _components,
int256[] memory _units,
address[] memory _modules,
IController _controller,
address _manager,
string memory _name,
string memory _symbol
)
public
ERC20(_name, _symbol)
{
controller = _controller;
manager = _manager;
positionMultiplier = PreciseUnitMath.preciseUnitInt();
components = _components;
for (uint256 i = 0; i < _modules.length; i++) {
moduleStates[_modules[i]] = ISetToken.ModuleState.PENDING;
}
for (uint256 j = 0; j < _components.length; j++) {
componentPositions[_components[j]].virtualUnit = _units[j];
}
}
function invoke(
address _target,
uint256 _value,
bytes calldata _data
)
external
onlyModule
whenLockedOnlyLocker
returns (bytes memory _returnValue)
{
_returnValue = _target.functionCallWithValue(_data, _value);
emit Invoked(_target, _value, _data, _returnValue);
return _returnValue;
}
function addComponent(address _component) external onlyModule whenLockedOnlyLocker {
require(!isComponent(_component), "Must not be component");
components.push(_component);
emit ComponentAdded(_component);
}
function removeComponent(address _component) external onlyModule whenLockedOnlyLocker {
components.removeStorage(_component);
emit ComponentRemoved(_component);
}
function editDefaultPositionUnit(address _component, int256 _realUnit) external onlyModule whenLockedOnlyLocker {
int256 virtualUnit = _convertRealToVirtualUnit(_realUnit);
componentPositions[_component].virtualUnit = virtualUnit;
emit DefaultPositionUnitEdited(_component, _realUnit);
}
function addExternalPositionModule(address _component, address _positionModule) external onlyModule whenLockedOnlyLocker {
require(!isExternalPositionModule(_component, _positionModule), "Module already added");
componentPositions[_component].externalPositionModules.push(_positionModule);
emit PositionModuleAdded(_component, _positionModule);
}
function removeExternalPositionModule(
address _component,
address _positionModule
)
external
onlyModule
whenLockedOnlyLocker
{
componentPositions[_component].externalPositionModules.removeStorage(_positionModule);
delete componentPositions[_component].externalPositions[_positionModule];
emit PositionModuleRemoved(_component, _positionModule);
}
function editExternalPositionUnit(
address _component,
address _positionModule,
int256 _realUnit
)
external
onlyModule
whenLockedOnlyLocker
{
int256 virtualUnit = _convertRealToVirtualUnit(_realUnit);
componentPositions[_component].externalPositions[_positionModule].virtualUnit = virtualUnit;
emit ExternalPositionUnitEdited(_component, _positionModule, _realUnit);
}
function editExternalPositionData(
address _component,
address _positionModule,
bytes calldata _data
)
external
onlyModule
whenLockedOnlyLocker
{
componentPositions[_component].externalPositions[_positionModule].data = _data;
emit ExternalPositionDataEdited(_component, _positionModule, _data);
}
function editPositionMultiplier(int256 _newMultiplier) external onlyModule whenLockedOnlyLocker {
_validateNewMultiplier(_newMultiplier);
positionMultiplier = _newMultiplier;
emit PositionMultiplierEdited(_newMultiplier);
}
function mint(address _account, uint256 _quantity) external onlyModule whenLockedOnlyLocker {
_mint(_account, _quantity);
}
function burn(address _account, uint256 _quantity) external onlyModule whenLockedOnlyLocker {
_burn(_account, _quantity);
}
function lock() external onlyModule {
require(!isLocked, "Must not be locked");
locker = msg.sender;
isLocked = true;
}
function unlock() external onlyModule {
require(isLocked, "Must be locked");
require(locker == msg.sender, "Must be locker");
delete locker;
isLocked = false;
}
function addModule(address _module) external onlyManager {
require(moduleStates[_module] == ISetToken.ModuleState.NONE, "Module must not be added");
require(controller.isModule(_module), "Must be enabled on Controller");
moduleStates[_module] = ISetToken.ModuleState.PENDING;
emit ModuleAdded(_module);
}
function removeModule(address _module) external onlyManager {
require(!isLocked, "Only when unlocked");
require(moduleStates[_module] == ISetToken.ModuleState.INITIALIZED, "Module must be added");
IModule(_module).removeModule();
moduleStates[_module] = ISetToken.ModuleState.NONE;
modules.removeStorage(_module);
emit ModuleRemoved(_module);
}
function removePendingModule(address _module) external onlyManager {
require(!isLocked, "Only when unlocked");
require(moduleStates[_module] == ISetToken.ModuleState.PENDING, "Module must be pending");
moduleStates[_module] = ISetToken.ModuleState.NONE;
emit PendingModuleRemoved(_module);
}
function initializeModule() external {
require(!isLocked, "Only when unlocked");
require(moduleStates[msg.sender] == ISetToken.ModuleState.PENDING, "Module must be pending");
moduleStates[msg.sender] = ISetToken.ModuleState.INITIALIZED;
modules.push(msg.sender);
emit ModuleInitialized(msg.sender);
}
function setManager(address _manager) external onlyManager {
require(!isLocked, "Only when unlocked");
address oldManager = manager;
manager = _manager;
emit ManagerEdited(_manager, oldManager);
}
function getComponents() external view returns(address[] memory) {
return components;
}
function getDefaultPositionRealUnit(address _component) public view returns(int256) {
return _convertVirtualToRealUnit(_defaultPositionVirtualUnit(_component));
}
function getExternalPositionRealUnit(address _component, address _positionModule) public view returns(int256) {
return _convertVirtualToRealUnit(_externalPositionVirtualUnit(_component, _positionModule));
}
function getExternalPositionModules(address _component) external view returns(address[] memory) {
return _externalPositionModules(_component);
}
function getExternalPositionData(address _component,address _positionModule) external view returns(bytes memory) {
return _externalPositionData(_component, _positionModule);
}
function getModules() external view returns (address[] memory) {
return modules;
}
function isComponent(address _component) public view returns(bool) {
return components.contains(_component);
}
function isExternalPositionModule(address _component, address _module) public view returns(bool) {
return _externalPositionModules(_component).contains(_module);
}
function isInitializedModule(address _module) external view returns (bool) {
return moduleStates[_module] == ISetToken.ModuleState.INITIALIZED;
}
function isPendingModule(address _module) external view returns (bool) {
return moduleStates[_module] == ISetToken.ModuleState.PENDING;
}
function getPositions() external view returns (ISetToken.Position[] memory) {
ISetToken.Position[] memory positions = new ISetToken.Position[](_getPositionCount());
uint256 positionCount = 0;
for (uint256 i = 0; i < components.length; i++) {
address component = components[i];
if (_defaultPositionVirtualUnit(component) > 0) {
positions[positionCount] = ISetToken.Position({
component: component,
module: address(0),
unit: getDefaultPositionRealUnit(component),
positionState: DEFAULT,
data: ""
});
positionCount++;
}
address[] memory externalModules = _externalPositionModules(component);
for (uint256 j = 0; j < externalModules.length; j++) {
address currentModule = externalModules[j];
positions[positionCount] = ISetToken.Position({
component: component,
module: currentModule,
unit: getExternalPositionRealUnit(component, currentModule),
positionState: EXTERNAL,
data: _externalPositionData(component, currentModule)
});
positionCount++;
}
}
return positions;
}
function getTotalComponentRealUnits(address _component) external view returns(int256) {
int256 totalUnits = getDefaultPositionRealUnit(_component);
address[] memory externalModules = _externalPositionModules(_component);
for (uint256 i = 0; i < externalModules.length; i++) {
totalUnits = totalUnits.add(getExternalPositionRealUnit(_component, externalModules[i]));
}
return totalUnits;
}
receive() external payable {}
function _defaultPositionVirtualUnit(address _component) internal view returns(int256) {
return componentPositions[_component].virtualUnit;
}
function _externalPositionModules(address _component) internal view returns(address[] memory) {
return componentPositions[_component].externalPositionModules;
}
function _externalPositionVirtualUnit(address _component, address _module) internal view returns(int256) {
return componentPositions[_component].externalPositions[_module].virtualUnit;
}
function _externalPositionData(address _component, address _module) internal view returns(bytes memory) {
return componentPositions[_component].externalPositions[_module].data;
}
function _convertRealToVirtualUnit(int256 _realUnit) internal view returns(int256) {
int256 virtualUnit = _realUnit.conservativePreciseDiv(positionMultiplier);
if (_realUnit > 0 && virtualUnit == 0) {
revert("Real to Virtual unit conversion invalid");
}
if (_realUnit > 0 && _convertVirtualToRealUnit(virtualUnit) == 0) {
revert("Virtual to Real unit conversion invalid");
}
return virtualUnit;
}
function _convertVirtualToRealUnit(int256 _virtualUnit) internal view returns(int256) {
return _virtualUnit.conservativePreciseMul(positionMultiplier);
}
function _validateNewMultiplier(int256 _newMultiplier) internal view {
int256 minVirtualUnit = _getPositionsAbsMinimumVirtualUnit();
require(minVirtualUnit.conservativePreciseMul(_newMultiplier) > 0, "New multiplier too small");
}
function _getPositionsAbsMinimumVirtualUnit() internal view returns(int256) {
uint256 minimumUnit = uint256(-1);
for (uint256 i = 0; i < components.length; i++) {
address component = components[i];
uint256 defaultUnit = _defaultPositionVirtualUnit(component).toUint256();
if (defaultUnit > 0 && defaultUnit < minimumUnit) {
minimumUnit = defaultUnit;
}
address[] memory externalModules = _externalPositionModules(component);
for (uint256 j = 0; j < externalModules.length; j++) {
address currentModule = externalModules[j];
uint256 virtualUnit = _absoluteValue(
_externalPositionVirtualUnit(component, currentModule)
);
if (virtualUnit > 0 && virtualUnit < minimumUnit) {
minimumUnit = virtualUnit;
}
}
}
return minimumUnit.toInt256();
}
function _getPositionCount() internal view returns (uint256) {
uint256 positionCount;
for (uint256 i = 0; i < components.length; i++) {
address component = components[i];
if (_defaultPositionVirtualUnit(component) > 0) {
positionCount++;
}
address[] memory externalModules = _externalPositionModules(component);
if (externalModules.length > 0) {
positionCount = positionCount.add(externalModules.length);
}
}
return positionCount;
}
function _absoluteValue(int256 _a) internal pure returns(uint256) {
return _a >= 0 ? _a.toUint256() : (-_a).toUint256();
}
function _validateOnlyModule() internal view {
require(
moduleStates[msg.sender] == ISetToken.ModuleState.INITIALIZED,
"Only the module can call"
);
require(
controller.isModule(msg.sender),
"Module must be enabled on controller"
);
}
function _validateOnlyManager() internal view {
require(msg.sender == manager, "Only manager can call");
}
function _validateWhenLockedOnlyLocker() internal view {
if (isLocked) {
require(msg.sender == locker, "When locked, only the locker can call");
}
}
}
