[
{
"path": ".circleci/config.yml",
"content": "version: 2\n\njobs:\n checkout_and_compile:\n docker:\n - image: circleci/node:10.11.0\n working_directory: ~/set-protocol-contracts\n steps:\n - checkout\n - setup_remote_docker:\n docker_layer_caching: false\n - restore_cache:\n key: module-cache-{{ checksum \"yarn.lock\" }}\n - run:\n name: Fetch Dependencies\n command: yarn install\n - save_cache:\n key: module-cache-{{ checksum \"yarn.lock\" }}\n paths:\n - node_modules\n - run:\n name: Transpile Contracts\n command: yarn prepare-test\n - save_cache:\n key: compiled-env-{{ .Environment.CIRCLE_SHA1 }}\n paths:\n - ~/set-protocol-contracts\n test:\n docker:\n - image: circleci/node:10.11.0\n working_directory: ~/set-protocol-contracts\n parallelism: 3\n steps:\n - setup_remote_docker:\n docker_layer_caching: false\n - run:\n name: Fetch solc version\n command: docker pull ethereum/solc:0.5.7\n - restore_cache:\n key: compiled-env-{{ .Environment.CIRCLE_SHA1 }}\n - run:\n name: Set Up Environment Variables\n command: cp .env.default .env\n - run:\n name: Test RPC\n command: yarn chain\n background: true\n - run:\n name: Truffle Test\n command: |\n TEST_FILES=\"$(circleci tests glob \"./transpiled/test/**/*.spec.js\" | circleci tests split --split-by=timings)\"\n yarn test-continuous ${TEST_FILES}\n\n coverage:\n docker:\n - image: circleci/node:10.11.0\n working_directory: ~/set-protocol-contracts\n steps:\n - setup_remote_docker:\n docker_layer_caching: false\n - run:\n name: Fetch solc version\n command: docker pull ethereum/solc:0.5.7\n - restore_cache:\n key: compiled-env-{{ .Environment.CIRCLE_SHA1 }}\n - run:\n name: Coverage\n command: yarn clean-chain && yarn coverage-continuous && cat coverage/lcov.info | ./node_modules/.bin/coveralls\n\nworkflows:\n version: 2\n build-and-test:\n jobs:\n - checkout_and_compile\n - test:\n requires:\n - checkout_and_compile\n - coverage:\n requires:\n - checkout_and_compile\n"
},
{
"path": ".gitignore",
"content": ".DS_Store\n/artifacts/json\n/artifacts/ts\n/build\n/cache\n/dist\n/node_modules\n/transpiled\n/types/generated/*\ncoverage.json\ncoverage/\n.env\n\n### Coverage artifacts (yarn coverage-setup) ###\ntest/*.js*\ntest/**/*.js*\ntypes/*.js*\ntypes/**/*.js*\n\n### Node ###\n\n# Logs\n*.log\n/logs\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\n\n# IDE Configs\n.vscode/*\n\n# Snapshot\nblockchain/\n\n# Ouputs\ndeployments/outputs.ts\n"
},
{
"path": ".prettierignore",
"content": "types/generated/\n"
},
{
"path": ".prettierrc",
"content": "# .prettierrc\nprintWidth: 100\nparser: typescript\ntabWidth: 2\ntrailingComma: all\narrowParens: always\n"
},
{
"path": ".solcover.js",
"content": "module.exports = {\n port: 8555,\n testrpcOptions: \"--db blockchain --networkId 50 --port 8555 --accounts 20 -e 1000000 -m 'concert load couple harbor equip island argue ramp clarify fence smart topic'\",\n testCommand: \"node --max-old-space-size=4096 ../node_modules/.bin/truffle test `find ./transpiled/test/contracts -name '*.spec.js'` --network coverage\",\n copyPackages: [\n 'openzeppelin-solidity',\n 'set-protocol-contract-utils'\n ],\n skipFiles: [\n 'Migrations.sol',\n 'lib/AddressArrayUtils.sol',\n 'mocks',\n 'external',\n // https://github.com/sc-forks/solidity-coverage/blob/master/docs/faq.md#why-are-send-and-transfer-throwing\n 'core/modules/RebalancingSetExchangeIssuanceModule.sol', // Transfer functions cannot be properly tested. See link above.\n 'core/modules/RebalancingSetIssuanceModule.sol', // Transfer functions cannot be properly tested. See link above.\n 'helper/RebalancingSetEthBidder.sol' // Transfer functions cannot be properly tested. See link above.\n ],\n};\n"
},
{
"path": ".soliumignore",
"content": "node_modules\ncontracts/mocks\ncontracts/Migrations.sol\ncontracts/external"
},
{
"path": ".soliumrc.json",
"content": "{\n \"extends\": \"solium:all\",\n \"plugins\": [\"security\"],\n \"rules\": {\n \"operator-whitespace\": 1,\n \"mixedcase\": 0,\n \"no-experimental\": 0,\n \"lbrace\": 0,\n \"max-len\": [\"warning\", 120],\n \"indentation\": [\"error\", 4],\n \"quotes\": [\"error\", \"double\"],\n \"arg-overflow\": [\"warning\", 3],\n \"security/enforce-explicit-visibility\": [\"error\"],\n \"security/no-block-members\": 0,\n \"security/no-named-returns\": [\"error\"],\n \"security/no-suicide-or-selfdestruct\": [\"error\"],\n \"security/no-var\": [\"error\"],\n \"security/no-inline-assembly\": \"off\"\n }\n}\n"
},
{
"path": "LICENSE",
"content": "Apache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n\"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n\"Licensor\" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\n\n\"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n\"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n\"Source\" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n\"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.\n\n\"Work\" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n\"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.\n\n\"Contribution\" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as \"Not a Contribution.\"\n\n\"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n2. Grant of Copyright License.\n\nSubject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License.\n\nSubject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\n\n4. Redistribution.\n\nYou may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\nYou must give any other recipients of the Work or Derivative Works a copy of this License; and\nYou must cause any modified files to carry prominent notices stating that You changed the files; and\nYou must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\nIf the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.\nYou may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n5. Submission of Contributions.\n\nUnless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n6. Trademarks.\n\nThis License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty.\n\nUnless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability.\n\nIn no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability.\n\nWhile redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS"
},
{
"path": "README.md",
"content": "![](\"https://s3-us-west-1.amazonaws.com/set-protocol/set-logo.svg\")
\n\n\n \n ![](\"https://img.shields.io/circleci/project/github/SetProtocol/set-protocol-contracts/master.svg\")
\n \n \n 
\n \n \n 
\n \n \n 
\n \n
\n\n# Set Protocol: A Specification for Token Abstraction\n\n## Contracts\n[Set Protocol](https://setprotocol.com/) is a specification for abstraction of higher order tokens on the ethereum blockchain written in the Solidity programming language. We use [Truffle](https://github.com/trufflesuite/truffle) as a development environment for compiling, testing, and deploying our contracts. See the [whitepaper](https://whitepaper.setprotocol.com) for more details about Set Protocol.\n\nMore details about our contract architecture and deployed contracts can also be found in our [wiki](https://docs.setprotocol.com/contracts).\n\n## Contributing\nWe highly encourage participation from the community to help shape the development of Set. If you are interested in developing on top of Set Protocol or have any questions, please ping us on [Discord](https://discord.gg/ZWY66aR).\n\n## Legacy\nFor legacy users, our audited V1 contracts can be found [here](https://github.com/SetProtocol/set-protocol-contracts/releases/tag/0.2.5).\n\n\n\n\n## Testing\n0. Docker Set up\n\n Firstly, you need to install Docker. The easiest way is to follow the Instructions on https://docs.docker.com/install/#supported-platforms\n\n You need to pull the docker image that you want to use by using the following command:\n\n ```\n docker pull ethereum/solc:0.5.7\n ```\n\n If you wish not to set up docker, you can turn off the `docker: true` flag in truffle.js\n\n1. Run yarn install\n\n ```\n yarn install\n ```\n\n2. Run an ethereum chain on a separate terminal window\n\n ```\n yarn chain\n ```\n\n3. Run unit tests\n\n ```\n yarn test\n ```\n"
},
{
"path": "artifacts/index.ts",
"content": "// Export ABIs\nexport { AddressArrayUtils } from \"./ts/AddressArrayUtils\";\nexport { AddressToAddressWhiteList } from \"./ts/AddressToAddressWhiteList\";\nexport { Auction } from \"./ts/Auction\";\nexport { AuctionMock } from \"./ts/AuctionMock\";\nexport { Authorizable } from \"./ts/Authorizable\";\nexport { BackwardCompatibility } from \"./ts/BackwardCompatibility\";\nexport { BadCTokenMock } from \"./ts/BadCTokenMock\";\nexport { BadTokenMock } from \"./ts/BadTokenMock\";\nexport { Bytes32Library } from \"./ts/Bytes32Library\";\nexport { CTokenExchangeIssuanceModule } from \"./ts/CTokenExchangeIssuanceModule\";\nexport { CTokenWhiteListed } from \"./ts/CTokenWhiteListed\";\nexport { CommonMath } from \"./ts/CommonMath\";\nexport { CommonValidationsLibrary } from \"./ts/CommonValidationsLibrary\";\nexport { CompoundUtils } from \"./ts/CompoundUtils\";\nexport { ConstantAuctionPriceCurve } from \"./ts/ConstantAuctionPriceCurve\";\nexport { Core } from \"./ts/Core\";\nexport { CoreAccounting } from \"./ts/CoreAccounting\";\nexport { CoreAdmin } from \"./ts/CoreAdmin\";\nexport { CoreFactory } from \"./ts/CoreFactory\";\nexport { CoreIssuance } from \"./ts/CoreIssuance\";\nexport { CoreIssuanceLibrary } from \"./ts/CoreIssuanceLibrary\";\nexport { CoreIssuanceLibraryMock } from \"./ts/CoreIssuanceLibraryMock\";\nexport { CoreMock } from \"./ts/CoreMock\";\nexport { CoreModuleInteraction } from \"./ts/CoreModuleInteraction\";\nexport { CoreOperationState } from \"./ts/CoreOperationState\";\nexport { CoreState } from \"./ts/CoreState\";\nexport { ERC20 } from \"./ts/ERC20\";\nexport { ERC20Detailed } from \"./ts/ERC20Detailed\";\nexport { ERC20Wrapper } from \"./ts/ERC20Wrapper\";\nexport { ERC20WrapperMock } from \"./ts/ERC20WrapperMock\";\nexport { ExchangeExecution } from \"./ts/ExchangeExecution\";\nexport { ExchangeHeaderLibrary } from \"./ts/ExchangeHeaderLibrary\";\nexport { ExchangeIssuanceLibrary } from \"./ts/ExchangeIssuanceLibrary\";\nexport { ExchangeIssuanceLibraryMock } from \"./ts/ExchangeIssuanceLibraryMock\";\nexport { ExchangeIssuanceModule } from \"./ts/ExchangeIssuanceModule\";\nexport { ExchangeWrapperLibrary } from \"./ts/ExchangeWrapperLibrary\";\nexport { ExchangeWrapperLibraryV2 } from \"./ts/ExchangeWrapperLibraryV2\";\nexport { FactoryUtilsLibrary } from \"./ts/FactoryUtilsLibrary\";\nexport { FailAuctionLibrary } from \"./ts/FailAuctionLibrary\";\nexport { FeeCalculatorMock } from \"./ts/FeeCalculatorMock\";\nexport { FixedFeeCalculator } from \"./ts/FixedFeeCalculator\";\nexport { FixedFeeCalculatorMock } from \"./ts/FixedFeeCalculatorMock\";\nexport { IAddressToAddressWhiteList } from \"./ts/IAddressToAddressWhiteList\";\nexport { IAssetData } from \"./ts/IAssetData\";\nexport { IAssetProxy } from \"./ts/IAssetProxy\";\nexport { IAssetProxyDispatcher } from \"./ts/IAssetProxyDispatcher\";\nexport { IAuctionPriceCurve } from \"./ts/IAuctionPriceCurve\";\nexport { IAuthorizable } from \"./ts/IAuthorizable\";\nexport { ICToken } from \"./ts/ICToken\";\nexport { ICore } from \"./ts/ICore\";\nexport { ICoreAccounting } from \"./ts/ICoreAccounting\";\nexport { ICoreIssuance } from \"./ts/ICoreIssuance\";\nexport { IERC20 } from \"./ts/IERC20\";\nexport { IExchange } from \"./ts/IExchange\";\nexport { IExchangeCore } from \"./ts/IExchangeCore\";\nexport { IExchangeIssuanceModule } from \"./ts/IExchangeIssuanceModule\";\nexport { IExchangeWrapper } from \"./ts/IExchangeWrapper\";\nexport { IFeeCalculator } from \"./ts/IFeeCalculator\";\nexport { ILiquidator } from \"./ts/ILiquidator\";\nexport { IMatchOrders } from \"./ts/IMatchOrders\";\nexport { IOracle } from \"./ts/IOracle\";\nexport { IOracleWhiteList } from \"./ts/IOracleWhiteList\";\nexport { IOwnable } from \"./ts/IOwnable\";\nexport { IPerformanceFeeCalculator } from \"./ts/IPerformanceFeeCalculator\";\nexport { IRebalanceAuctionModule } from \"./ts/IRebalanceAuctionModule\";\nexport { IRebalancingSetFactory } from \"./ts/IRebalancingSetFactory\";\nexport { IRebalancingSetToken } from \"./ts/IRebalancingSetToken\";\nexport { IRebalancingSetTokenV2 } from \"./ts/IRebalancingSetTokenV2\";\nexport { IRebalancingSetTokenV3 } from \"./ts/IRebalancingSetTokenV3\";\nexport { ISetFactory } from \"./ts/ISetFactory\";\nexport { ISetToken } from \"./ts/ISetToken\";\nexport { ISignatureValidator } from \"./ts/ISignatureValidator\";\nexport { ISocialAllocator } from \"./ts/ISocialAllocator\";\nexport { ISocialTradingManager } from \"./ts/ISocialTradingManager\";\nexport { ITransactions } from \"./ts/ITransactions\";\nexport { ITransferProxy } from \"./ts/ITransferProxy\";\nexport { IValidator } from \"./ts/IValidator\";\nexport { IVault } from \"./ts/IVault\";\nexport { IWETH } from \"./ts/IWETH\";\nexport { IWallet } from \"./ts/IWallet\";\nexport { IWhiteList } from \"./ts/IWhiteList\";\nexport { IWrapperFunctions } from \"./ts/IWrapperFunctions\";\nexport { IncentiveFee } from \"./ts/IncentiveFee\";\nexport { Initializable } from \"./ts/Initializable\";\nexport { InvalidReturnTokenMock } from \"./ts/InvalidReturnTokenMock\";\nexport { Issuance } from \"./ts/Issuance\";\nexport { KyberNetworkProxyInterface } from \"./ts/KyberNetworkProxyInterface\";\nexport { KyberNetworkWrapper } from \"./ts/KyberNetworkWrapper\";\nexport { LibAssetProxyErrors } from \"./ts/LibAssetProxyErrors\";\nexport { LibBytes } from \"./ts/LibBytes\";\nexport { LibConstants } from \"./ts/LibConstants\";\nexport { LibEIP712 } from \"./ts/LibEIP712\";\nexport { LibExchangeErrors } from \"./ts/LibExchangeErrors\";\nexport { LibFillResults } from \"./ts/LibFillResults\";\nexport { LibOrder } from \"./ts/LibOrder\";\nexport { LinearAuction } from \"./ts/LinearAuction\";\nexport { LinearAuctionLiquidator } from \"./ts/LinearAuctionLiquidator\";\nexport { LinearAuctionMock } from \"./ts/LinearAuctionMock\";\nexport { LinearAuctionPriceCurve } from \"./ts/LinearAuctionPriceCurve\";\nexport { LiquidatorMock } from \"./ts/LiquidatorMock\";\nexport { LiquidatorProxy } from \"./ts/LiquidatorProxy\";\nexport { Math } from \"./ts/Math\";\nexport { Migrations } from \"./ts/Migrations\";\nexport { ModuleCoreState } from \"./ts/ModuleCoreState\";\nexport { ModuleCoreStateV2 } from \"./ts/ModuleCoreStateV2\";\nexport { NoDecimalTokenMock } from \"./ts/NoDecimalTokenMock\";\nexport { NoXferReturnTokenMock } from \"./ts/NoXferReturnTokenMock\";\nexport { OracleWhiteList } from \"./ts/OracleWhiteList\";\nexport { Ownable } from \"./ts/Ownable\";\nexport { PerformanceFeeCalculator } from \"./ts/PerformanceFeeCalculator\";\nexport { PerformanceFeeLibrary } from \"./ts/PerformanceFeeLibrary\";\nexport { PlaceBidLibrary } from \"./ts/PlaceBidLibrary\";\nexport { PlaceBidMock } from \"./ts/PlaceBidMock\";\nexport { ProposeLibrary } from \"./ts/ProposeLibrary\";\nexport { Rebalance } from \"./ts/Rebalance\";\nexport { RebalanceAuctionModule } from \"./ts/RebalanceAuctionModule\";\nexport { RebalanceAuctionModuleMock } from \"./ts/RebalanceAuctionModuleMock\";\nexport { RebalanceMock } from \"./ts/RebalanceMock\";\nexport { RebalanceStateSetTokenMock } from \"./ts/RebalanceStateSetTokenMock\";\nexport { RebalancingBid } from \"./ts/RebalancingBid\";\nexport { RebalancingFailure } from \"./ts/RebalancingFailure\";\nexport { RebalancingLibrary } from \"./ts/RebalancingLibrary\";\nexport { RebalancingSetCTokenBidder } from \"./ts/RebalancingSetCTokenBidder\";\nexport { RebalancingSetCTokenExchangeIssuanceModule } from \"./ts/RebalancingSetCTokenExchangeIssuanceModule\";\nexport { RebalancingSetCTokenIssuanceModule } from \"./ts/RebalancingSetCTokenIssuanceModule\";\nexport { RebalancingSetEthBidder } from \"./ts/RebalancingSetEthBidder\";\nexport { RebalancingSetExchangeIssuanceModule } from \"./ts/RebalancingSetExchangeIssuanceModule\";\nexport { RebalancingSetFeeMock } from \"./ts/RebalancingSetFeeMock\";\nexport { RebalancingSetIssuance } from \"./ts/RebalancingSetIssuance\";\nexport { RebalancingSetIssuanceMock } from \"./ts/RebalancingSetIssuanceMock\";\nexport { RebalancingSetIssuanceModule } from \"./ts/RebalancingSetIssuanceModule\";\nexport { RebalancingSetState } from \"./ts/RebalancingSetState\";\nexport { RebalancingSetToken } from \"./ts/RebalancingSetToken\";\nexport { RebalancingSetTokenFactory } from \"./ts/RebalancingSetTokenFactory\";\nexport { RebalancingSetTokenV2 } from \"./ts/RebalancingSetTokenV2\";\nexport { RebalancingSetTokenV2Factory } from \"./ts/RebalancingSetTokenV2Factory\";\nexport { RebalancingSetTokenV3 } from \"./ts/RebalancingSetTokenV3\";\nexport { RebalancingSetTokenV3Factory } from \"./ts/RebalancingSetTokenV3Factory\";\nexport { RebalancingSettlement } from \"./ts/RebalancingSettlement\";\nexport { RebalancingStart } from \"./ts/RebalancingStart\";\nexport { ReentrancyGuard } from \"./ts/ReentrancyGuard\";\nexport { SafeMath } from \"./ts/SafeMath\";\nexport { ScaleValidations } from \"./ts/ScaleValidations\";\nexport { SetMath } from \"./ts/SetMath\";\nexport { SetMathMock } from \"./ts/SetMathMock\";\nexport { SetToken } from \"./ts/SetToken\";\nexport { SetTokenFactory } from \"./ts/SetTokenFactory\";\nexport { SetTokenLibrary } from \"./ts/SetTokenLibrary\";\nexport { SetTokenLibraryMock } from \"./ts/SetTokenLibraryMock\";\nexport { SetUSDValuation } from \"./ts/SetUSDValuation\";\nexport { SetUSDValuationMock } from \"./ts/SetUSDValuationMock\";\nexport { SettleRebalanceLibrary } from \"./ts/SettleRebalanceLibrary\";\nexport { SocialTradingLibrary } from \"./ts/SocialTradingLibrary\";\nexport { SocialTradingManagerMock } from \"./ts/SocialTradingManagerMock\";\nexport { StandardTokenMock } from \"./ts/StandardTokenMock\";\nexport { StandardTokenWithFeeMock } from \"./ts/StandardTokenWithFeeMock\";\nexport { StartRebalanceLibrary } from \"./ts/StartRebalanceLibrary\";\nexport { TimeLockUpgrade } from \"./ts/TimeLockUpgrade\";\nexport { TimeLockUpgradeV2 } from \"./ts/TimeLockUpgradeV2\";\nexport { TokenFlush } from \"./ts/TokenFlush\";\nexport { TokenFlushMock } from \"./ts/TokenFlushMock\";\nexport { TransferProxy } from \"./ts/TransferProxy\";\nexport { TWAPLiquidator } from \"./ts/TWAPLiquidator\";\nexport { TwoAssetPriceBoundedLinearAuction } from \"./ts/TwoAssetPriceBoundedLinearAuction\";\nexport { TwoAssetPriceBoundedLinearAuctionMock } from \"./ts/TwoAssetPriceBoundedLinearAuctionMock\";\nexport { UpdatableConstantAuctionPriceCurve } from \"./ts/UpdatableConstantAuctionPriceCurve\";\nexport { Vault } from \"./ts/Vault\";\nexport { WETH9 } from \"./ts/WETH9\";\nexport { WethMock } from \"./ts/WethMock\";\nexport { WhiteList } from \"./ts/WhiteList\";\nexport { ZeroExExchangeWrapper } from \"./ts/ZeroExExchangeWrapper\";\nexport { ZeroExOrderLibrary } from \"./ts/ZeroExOrderLibrary\";\nexport { ZeroExOrderLibraryMock } from \"./ts/ZeroExOrderLibraryMock\";\n\n\n// Export abi-gen contract wrappers\nexport {\n AddressToAddressWhiteListContract,\n AuthorizableContract,\n BadCTokenMockContract,\n BadTokenMockContract,\n BaseContract,\n Bytes32LibraryContract,\n CommonValidationsLibraryContract,\n ConstantAuctionPriceCurveContract,\n CoreContract,\n CoreIssuanceLibraryContract,\n CoreIssuanceLibraryMockContract,\n CoreMockContract,\n CTokenExchangeIssuanceModuleContract,\n ERC20DetailedContract,\n ERC20WrapperContract,\n ERC20WrapperMockContract,\n ExchangeIssuanceLibraryContract,\n ExchangeIssuanceLibraryMockContract,\n ExchangeIssuanceModuleContract,\n FailAuctionLibraryContract,\n FactoryUtilsLibraryContract,\n FixedFeeCalculatorContract,\n IAuctionPriceCurveContract,\n InvalidReturnTokenMockContract,\n KyberNetworkWrapperContract,\n LinearAuctionLiquidatorContract,\n LinearAuctionPriceCurveContract,\n NoDecimalTokenMockContract,\n NoXferReturnTokenMockContract,\n OracleWhiteListContract,\n PerformanceFeeCalculatorContract,\n PlaceBidLibraryContract,\n PlaceBidMockContract,\n ProposeLibraryContract,\n RebalanceAuctionModuleContract,\n RebalanceMockContract,\n RebalancingSetCTokenBidderContract,\n RebalancingSetCTokenExchangeIssuanceModuleContract,\n RebalancingSetCTokenIssuanceModuleContract,\n RebalancingSetEthBidderContract,\n RebalancingSetExchangeIssuanceModuleContract,\n RebalancingSetIssuanceMockContract,\n RebalancingSetIssuanceModuleContract,\n RebalancingSetTokenContract,\n RebalancingSetTokenFactoryContract,\n RebalancingSetTokenV2Contract,\n RebalancingSetTokenV2FactoryContract,\n RebalancingSetTokenV3Contract,\n RebalancingSetTokenV3FactoryContract,\n RebalanceStateSetTokenMockContract,\n SetMathMockContract,\n SettleRebalanceLibraryContract,\n SetTokenContract,\n SetTokenFactoryContract,\n SetTokenLibraryContract,\n SetTokenLibraryMockContract,\n SetUSDValuationMockContract,\n SocialTradingManagerMockContract,\n StandardTokenMockContract,\n StandardTokenWithFeeMockContract,\n StartRebalanceLibraryContract,\n TimeLockUpgradeContract,\n TimeLockUpgradeV2Contract,\n TokenFlushMockContract,\n TransferProxyContract,\n TWAPLiquidatorContract,\n VaultContract,\n WethMockContract,\n WhiteListContract,\n ZeroExExchangeWrapperContract,\n ZeroExOrderLibraryMockContract,\n} from \"../utils/contracts\";\n\nexport {\n CompoundHelper,\n CoreHelper,\n ERC20Helper,\n FeeCalculatorHelper,\n LibraryMockHelper,\n LiquidatorHelper,\n RebalancingHelper,\n RebalancingSetBidderHelper,\n RebalancingSetV2Helper,\n RebalancingSetV3Helper,\n RebalanceTestSetup,\n ValuationHelper\n} from '../utils/helpers';\n\nexport {\n Blockchain\n} from '../utils/blockchain'\n"
},
{
"path": "buidler.config.ts",
"content": "import { BuidlerConfig, usePlugin, internalTask } from \"@nomiclabs/buidler/config\";\nimport { TASK_COMPILE_RUN_COMPILER } from \"@nomiclabs/buidler/builtin-tasks/task-names\";\nimport { execSync } from \"child_process\";\n\nusePlugin(\"@nomiclabs/buidler-truffle5\");\nusePlugin(\"@nomiclabs/buidler-web3\");\n\n\n//\n// Register alias\n//\nconst moduleAlias = require('module-alias');\nmoduleAlias.addAlias('@utils', __dirname + '/utils');\n\ninternalTask(TASK_COMPILE_RUN_COMPILER).setAction(async ({ input }, { config }, runSuper) => {\n let solcVersionOutput = \"\";\n try {\n solcVersionOutput = execSync(`solc --version`).toString();\n } catch (error) {\n // Probably failed because solc wasn't installed. We do nothing here.\n }\n\n console.log(\"Output\", solcVersionOutput);\n\n if (!solcVersionOutput.includes(config.solc.version)) {\n console.log(`Using solcjs`);\n return runSuper();\n }\n\n console.log(`Using native solc`);\n const output = execSync(`solc --standard-json`, {\n input: JSON.stringify(input, undefined, 2),\n });\n\n return JSON.parse(output.toString(`utf8`));\n});\n\nconst config: BuidlerConfig = {\n solc: {\n version: \"0.5.7\",\n optimizer: {\n enabled: true,\n runs: 200,\n },\n evmVersion: \"byzantium\",\n },\n paths: {\n artifacts: \"./build/contracts\",\n tests: \"./transpiled/test/contracts\",\n },\n networks: {\n buidlerevm: {\n blockGasLimit: 20000000,\n },\n },\n};\n\nexport default config;"
},
{
"path": "contracts/Migrations.sol",
"content": "pragma solidity 0.5.7;\n\n// We leave the migrations file so that truffle can run tests properly\n// even though the migration is never deployed.\ncontract Migrations {}\n"
},
{
"path": "contracts/core/Core.sol",
"content": " /*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { CoreAccounting } from \"./extensions/CoreAccounting.sol\";\nimport { CoreAdmin } from \"./extensions/CoreAdmin.sol\";\nimport { CoreFactory } from \"./extensions/CoreFactory.sol\";\nimport { CoreIssuance } from \"./extensions/CoreIssuance.sol\";\nimport { CoreModuleInteraction } from \"./extensions/CoreModuleInteraction.sol\";\nimport { ITransferProxy } from \"./interfaces/ITransferProxy.sol\";\nimport { IVault } from \"./interfaces/IVault.sol\";\n\n\n/**\n * @title Core\n * @author Set Protocol\n *\n * The Core contract acts as a coordinator handling issuing, redeeming, and\n * creating Sets, as well as all collateral flows throughout the system. Core\n * is also responsible for tracking state and exposing methods to modules\n */\n /* solium-disable-next-line no-empty-blocks */\ncontract Core is\n CoreAccounting,\n CoreAdmin,\n CoreFactory,\n CoreIssuance,\n CoreModuleInteraction\n{\n /**\n * Constructor function for Core\n *\n * @param _transferProxy The address of the transfer proxy\n * @param _vault The address of the vault\n */\n constructor(\n address _transferProxy,\n address _vault\n )\n public\n {\n // Commit passed address to transferProxyAddress state variable\n state.transferProxy = _transferProxy;\n\n // Instantiate instance of transferProxy\n state.transferProxyInstance = ITransferProxy(_transferProxy);\n\n // Commit passed address to vault state variable\n state.vault = _vault;\n\n // Instantiate instance of vault\n state.vaultInstance = IVault(_vault);\n }\n}\n"
},
{
"path": "contracts/core/TransferProxy.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { Authorizable } from \"set-protocol-contract-utils/contracts/lib/Authorizable.sol\";\n\nimport { ERC20Wrapper } from \"../lib/ERC20Wrapper.sol\";\n\n\n/**\n * @title TransferProxy\n * @author Set Protocol\n *\n * The transferProxy contract is responsible for moving tokens through the system to\n * assist with issuance and usage from modules.\n */\n\ncontract TransferProxy is\n Authorizable\n{\n using SafeMath for uint256;\n\n /* ============ External Functions ============ */\n\n /**\n * Transfers tokens from an address (that has set allowance on the proxy).\n * Can only be called by Core.\n *\n * @param _token The address of the ERC20 token\n * @param _quantity The number of tokens to transfer\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n */\n function transfer(\n address _token,\n uint256 _quantity,\n address _from,\n address _to\n )\n public\n onlyAuthorized\n {\n // Call specified ERC20 contract to transfer tokens (via proxy).\n if (_quantity > 0) {\n // Retrieve current balance of token for the receiver\n uint256 existingBalance = ERC20Wrapper.balanceOf(\n _token,\n _to\n );\n\n ERC20Wrapper.transferFrom(\n _token,\n _from,\n _to,\n _quantity\n );\n\n // Get new balance of transferred token for receiver\n uint256 newBalance = ERC20Wrapper.balanceOf(\n _token,\n _to\n );\n\n // Verify transfer quantity is reflected in balance\n require(\n newBalance == existingBalance.add(_quantity),\n \"TransferProxy.transfer: Invalid post transfer balance\"\n );\n }\n }\n\n /**\n * Transfers tokens from an address (that has set allowance on the proxy).\n * Can only be called by Core.\n *\n * @param _tokens The addresses of the ERC20 token\n * @param _quantities The numbers of tokens to transfer\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n */\n function batchTransfer(\n address[] calldata _tokens,\n uint256[] calldata _quantities,\n address _from,\n address _to\n )\n external\n onlyAuthorized\n {\n // Storing token count to local variable to save on invocation\n uint256 tokenCount = _tokens.length;\n\n // Confirm and empty _tokens array is not passed\n require(\n tokenCount > 0,\n \"TransferProxy.batchTransfer: Tokens must not be empty\"\n );\n\n // Confirm there is one quantity for every token address\n require(\n tokenCount == _quantities.length,\n \"TransferProxy.batchTransfer: Tokens and quantities lengths mismatch\"\n );\n\n for (uint256 i = 0; i < tokenCount; i++) {\n if (_quantities[i] > 0) {\n transfer(\n _tokens[i],\n _quantities[i],\n _from,\n _to\n );\n }\n }\n }\n\n}\n"
},
{
"path": "contracts/core/Vault.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { Authorizable } from \"set-protocol-contract-utils/contracts/lib/Authorizable.sol\";\n\nimport { ERC20Wrapper } from \"../lib/ERC20Wrapper.sol\";\n\n\n/**\n * @title Vault\n * @author Set Protocol\n *\n * The vault contract is responsible for holding all funds and keeping track of the\n * fund state and which Sets own which funds.\n *\n */\n\ncontract Vault is\n Authorizable\n{\n // Use SafeMath library for all uint256 arithmetic\n using SafeMath for uint256;\n\n /* ============ State Variables ============ */\n\n // Mapping of token address to map of owner or Set address to balance.\n // Example of mapping below:\n // +--------------+---------------------+--------+\n // | TokenAddress | Set OR User Address | Amount |\n // +--------------+---------------------+--------+\n // | TokenA | User 0x123 | 500 |\n // | | User 0xABC | 300 |\n // | | Set 0x456 | 1000 |\n // | TokenB | User 0xDEF | 100 |\n // | | Set 0xSET | 700 |\n // +--------------+---------------------+--------+\n mapping (address => mapping (address => uint256)) public balances;\n\n /* ============ External Functions ============ */\n\n /*\n * Withdraws user's unassociated tokens to user account. Can only be\n * called by authorized core contracts.\n *\n * @param _token The address of the ERC20 token\n * @param _to The address to transfer token to\n * @param _quantity The number of tokens to transfer\n */\n function withdrawTo(\n address _token,\n address _to,\n uint256 _quantity\n )\n public\n onlyAuthorized\n {\n if (_quantity > 0) {\n // Retrieve current balance of token for the vault\n uint256 existingVaultBalance = ERC20Wrapper.balanceOf(\n _token,\n address(this)\n );\n\n // Call specified ERC20 token contract to transfer tokens from Vault to user\n ERC20Wrapper.transfer(\n _token,\n _to,\n _quantity\n );\n\n // Verify transfer quantity is reflected in balance\n uint256 newVaultBalance = ERC20Wrapper.balanceOf(\n _token,\n address(this)\n );\n // Check to make sure current balances are as expected\n require(\n newVaultBalance == existingVaultBalance.sub(_quantity),\n \"Vault.withdrawTo: Invalid post withdraw balance\"\n ); \n }\n }\n\n /*\n * Increment quantity owned of a token for a given address. Can\n * only be called by authorized core contracts.\n *\n * @param _token The address of the ERC20 token\n * @param _owner The address of the token owner\n * @param _quantity The number of tokens to attribute to owner\n */\n function incrementTokenOwner(\n address _token,\n address _owner,\n uint256 _quantity\n )\n public\n onlyAuthorized\n {\n if (_quantity > 0) {\n // Increment balances state variable adding _quantity to user's token amount\n balances[_token][_owner] = balances[_token][_owner].add(_quantity); \n }\n }\n\n /*\n * Decrement quantity owned of a token for a given address. Can only\n * be called by authorized core contracts.\n *\n * @param _token The address of the ERC20 token\n * @param _owner The address of the token owner\n * @param _quantity The number of tokens to distribute to owner\n */\n function decrementTokenOwner(\n address _token,\n address _owner,\n uint256 _quantity\n )\n public\n onlyAuthorized\n {\n // Require that user has enough unassociated tokens to withdraw tokens or issue Set\n require(\n balances[_token][_owner] >= _quantity,\n \"Vault.decrementTokenOwner: Insufficient token balance\"\n );\n\n if (_quantity > 0) {\n // Decrement balances state variable subtracting _quantity to user's token amount\n balances[_token][_owner] = balances[_token][_owner].sub(_quantity); \n }\n }\n\n /**\n * Transfers tokens associated with one account to another account in the vault\n *\n * @param _token Address of token being transferred\n * @param _from Address token being transferred from\n * @param _to Address token being transferred to\n * @param _quantity Amount of tokens being transferred\n */\n\n function transferBalance(\n address _token,\n address _from,\n address _to,\n uint256 _quantity\n )\n public\n onlyAuthorized\n {\n if (_quantity > 0) {\n // Require that user has enough unassociated tokens to withdraw tokens or issue Set\n require(\n balances[_token][_from] >= _quantity,\n \"Vault.transferBalance: Insufficient token balance\"\n );\n\n // Decrement balances state variable subtracting _quantity to user's token amount\n balances[_token][_from] = balances[_token][_from].sub(_quantity);\n\n // Increment balances state variable adding _quantity to user's token amount\n balances[_token][_to] = balances[_token][_to].add(_quantity); \n }\n }\n\n /*\n * Withdraws user's unassociated tokens to user account. Can only be\n * called by authorized core contracts.\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _to The address of the recipient\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchWithdrawTo(\n address[] calldata _tokens,\n address _to,\n uint256[] calldata _quantities\n )\n external\n onlyAuthorized\n {\n // Storing token count to local variable to save on invocation\n uint256 tokenCount = _tokens.length;\n\n // Confirm and empty _tokens array is not passed\n require(\n tokenCount > 0,\n \"Vault.batchWithdrawTo: Tokens must not be empty\"\n );\n\n // Confirm there is one quantity for every token address\n require(\n tokenCount == _quantities.length,\n \"Vault.batchWithdrawTo: Tokens and quantities lengths mismatch\"\n );\n\n for (uint256 i = 0; i < tokenCount; i++) {\n withdrawTo(\n _tokens[i],\n _to,\n _quantities[i]\n );\n }\n }\n\n /*\n * Increment quantites owned of a collection of tokens for a given address. Can\n * only be called by authorized core contracts.\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchIncrementTokenOwner(\n address[] calldata _tokens,\n address _owner,\n uint256[] calldata _quantities\n )\n external\n onlyAuthorized\n {\n // Storing token count to local variable to save on invocation\n uint256 tokenCount = _tokens.length;\n\n // Confirm and empty _tokens array is not passed\n require(\n tokenCount > 0,\n \"Vault.batchIncrementTokenOwner: Tokens must not be empty\"\n );\n\n // Confirm there is one quantity for every token address\n require(\n tokenCount == _quantities.length,\n \"Vault.batchIncrementTokenOwner: Tokens and quantities lengths mismatch\"\n );\n\n for (uint256 i = 0; i < tokenCount; i++) {\n incrementTokenOwner(\n _tokens[i],\n _owner,\n _quantities[i]\n );\n }\n }\n\n /*\n * Decrements quantites owned of a collection of tokens for a given address. Can\n * only be called by authorized core contracts.\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchDecrementTokenOwner(\n address[] calldata _tokens,\n address _owner,\n uint256[] calldata _quantities\n )\n external\n onlyAuthorized\n {\n // Storing token count to local variable to save on invocation\n uint256 tokenCount = _tokens.length;\n\n // Confirm and empty _tokens array is not passed\n require(\n tokenCount > 0,\n \"Vault.batchDecrementTokenOwner: Tokens must not be empty\"\n );\n\n // Confirm there is one quantity for every token address\n require(\n tokenCount == _quantities.length,\n \"Vault.batchDecrementTokenOwner: Tokens and quantities lengths mismatch\"\n );\n\n for (uint256 i = 0; i < tokenCount; i++) {\n decrementTokenOwner(\n _tokens[i],\n _owner,\n _quantities[i]\n );\n }\n }\n\n /**\n * Transfers tokens associated with one account to another account in the vault\n *\n * @param _tokens Addresses of tokens being transferred\n * @param _from Address tokens being transferred from\n * @param _to Address tokens being transferred to\n * @param _quantities Amounts of tokens being transferred\n */\n function batchTransferBalance(\n address[] calldata _tokens,\n address _from,\n address _to,\n uint256[] calldata _quantities\n )\n external\n onlyAuthorized\n {\n // Storing token count to local variable to save on invocation\n uint256 tokenCount = _tokens.length;\n\n // Confirm and empty _tokens array is not passed\n require(\n tokenCount > 0,\n \"Vault.batchTransferBalance: Tokens must not be empty\"\n );\n\n // Confirm there is one quantity for every token address\n require(\n tokenCount == _quantities.length,\n \"Vault.batchTransferBalance: Tokens and quantities lengths mismatch\"\n );\n\n for (uint256 i = 0; i < tokenCount; i++) {\n transferBalance(\n _tokens[i],\n _from,\n _to,\n _quantities[i]\n );\n }\n }\n\n /*\n * Get balance of particular contract for owner.\n *\n * @param _token The address of the ERC20 token\n * @param _owner The address of the token owner\n */\n function getOwnerBalance(\n address _token,\n address _owner\n )\n external\n view\n returns (uint256)\n {\n // Return owners token balance\n return balances[_token][_owner];\n }\n}\n"
},
{
"path": "contracts/core/exchange-wrappers/KyberNetworkWrapper.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\nimport { ExchangeWrapperLibrary } from \"../lib/ExchangeWrapperLibrary.sol\";\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { KyberNetworkProxyInterface } from \"../../external/KyberNetwork/KyberNetworkProxyInterface.sol\";\nimport { LibBytes } from \"../../external/0x/LibBytes.sol\";\n\n\n/**\n * @title KyberNetworkWrapper\n * @author Set Protocol\n *\n * The KyberNetworkWrapper contract wrapper to interface with KyberNetwork for reserve liquidity\n */\ncontract KyberNetworkWrapper {\n using LibBytes for bytes;\n using SafeMath for uint256;\n\n /* ============ State Variables ============ */\n\n address public core;\n address public kyberNetworkProxy;\n address public setTransferProxy;\n\n uint256 public KYBER_TRADE_LENGTH = 160;\n\n // ============ Structs ============\n\n struct KyberTrade {\n address destinationToken;\n address sourceToken;\n uint256 sourceTokenQuantity;\n uint256 minimumConversionRate;\n uint256 maxDestinationQuantity;\n }\n\n /* ============ Constructor ============ */\n\n /**\n * Initialize exchange wrapper with required addresses to facilitate Kyber trades\n *\n * @param _core Deployed Core contract\n * @param _kyberNetworkProxy KyberNetwork contract for filling orders\n * @param _setTransferProxy Set Protocol transfer proxy contract\n */\n constructor(\n address _core,\n address _kyberNetworkProxy,\n address _setTransferProxy\n )\n public\n {\n core = _core;\n kyberNetworkProxy = _kyberNetworkProxy;\n setTransferProxy = _setTransferProxy;\n }\n\n /* ============ Public Functions ============ */\n\n /**\n * Returns the conversion rate between the issuance order maker token and the set component token\n * in 18 decimals, regardless of component token's decimals\n *\n * @param _sourceTokens Address of source token used in exchange orders\n * @param _destinationTokens Address of destination token to trade for\n * @param _quantities Amount of maker token to exchange for component token\n * @return uint256[] Conversion rate in wei\n * @return uint256[] Slippage in wei\n */\n function conversionRate(\n address[] calldata _sourceTokens,\n address[] calldata _destinationTokens,\n uint256[] calldata _quantities\n )\n external\n view\n returns (uint256[] memory, uint256[] memory)\n {\n uint256 rateCount = _sourceTokens.length;\n uint256[] memory expectedRates = new uint256[](rateCount);\n uint256[] memory slippageRates = new uint256[](rateCount);\n \n for (uint256 i = 0; i < rateCount; i++) {\n (expectedRates[i], slippageRates[i]) = KyberNetworkProxyInterface(kyberNetworkProxy).getExpectedRate(\n _sourceTokens[i],\n _destinationTokens[i],\n _quantities[i]\n );\n }\n\n return (\n expectedRates,\n slippageRates\n );\n }\n\n /**\n * IExchangeWrapper interface delegate method.\n *\n * Parses and executes Kyber trades. Depending on conversion rate, Kyber trades may result in change.\n * We currently pass change back to the issuance order maker, exploring how it can safely be passed to the taker.\n *\n *\n * @param _exchangeData Standard exchange wrapper interface object containing exchange metadata\n * @param _tradesData Arbitrary bytes data for any information to pass to the exchange\n * @return ExchangeWrapperLibrary.ExchangeResults Struct containing component acquisition results\n */\n function exchange(\n ExchangeWrapperLibrary.ExchangeData memory _exchangeData,\n bytes memory _tradesData\n )\n public\n returns (ExchangeWrapperLibrary.ExchangeResults memory)\n {\n require(\n ICore(core).validModules(msg.sender),\n \"KyberNetworkWrapper.exchange: Sender must be approved module\"\n );\n\n uint256 tradesCount = _exchangeData.orderCount;\n address[] memory sendTokens = new address[](tradesCount);\n address[] memory receiveTokens = new address[](tradesCount);\n uint256[] memory receiveTokensAmounts = new uint256[](tradesCount);\n\n // Parse and execute the trade at the current offset via the KyberNetworkProxy, each kyber trade is 160 bytes\n for (uint256 i = 0; i < tradesCount; i++) {\n // Parse Kyber trade at the current offset\n KyberTrade memory trade = parseKyberTrade(\n _tradesData,\n i.mul(KYBER_TRADE_LENGTH)\n );\n\n // Ensure the caller's source token is allowed to be transferred by \n // KyberNetworkProxy as the source token\n ERC20Wrapper.ensureAllowance(\n trade.sourceToken,\n address(this),\n kyberNetworkProxy,\n trade.sourceTokenQuantity\n );\n\n // Track the send tokens to ensure any leftovers are returned to the user\n sendTokens[i] = trade.sourceToken;\n\n // Execute Kyber trade\n (receiveTokens[i], receiveTokensAmounts[i]) = tradeOnKyberReserve(trade);\n }\n\n // Return leftover send tokens to the original caller\n ExchangeWrapperLibrary.returnLeftoverSendTokens(\n sendTokens,\n _exchangeData.caller\n );\n\n return ExchangeWrapperLibrary.ExchangeResults({\n receiveTokens: receiveTokens,\n receiveTokenAmounts: receiveTokensAmounts\n });\n }\n\n /* ============ Private ============ */\n\n /**\n * Parses and executes Kyber trade\n *\n * @return address Address of set component to trade for\n * @return uint256 Amount of set component received in trade\n */\n function tradeOnKyberReserve(\n KyberTrade memory _trade\n )\n private\n returns (address, uint256)\n {\n // Execute Kyber trade via deployed KyberNetworkProxy contract\n uint256 destinationTokenQuantity = KyberNetworkProxyInterface(kyberNetworkProxy).trade(\n _trade.sourceToken,\n _trade.sourceTokenQuantity,\n _trade.destinationToken,\n address(this),\n _trade.maxDestinationQuantity,\n _trade.minimumConversionRate,\n address(0)\n );\n\n // Ensure the destination token is allowed to be transferred by Set TransferProxy\n ERC20Wrapper.ensureAllowance(\n _trade.destinationToken,\n address(this),\n setTransferProxy,\n destinationTokenQuantity\n );\n\n return (\n _trade.destinationToken,\n destinationTokenQuantity\n );\n }\n\n /*\n * Parses the bytes array for a Kyber trade\n *\n * | Data | Location |\n * |----------------------------|-------------------------------|\n * | destinationToken | 0 |\n * | sourceTokenQuantity | 32 |\n * | sourceTokenQuantity | 64 |\n * | minimumConversionRate | 96 |\n * | maxDestinationQuantity | 128 |\n *\n * @param _tradesData Byte array of (multiple) Kyber trades\n * @param _offset Offset to start scanning for Kyber trade body\n * @return KyberTrade KyberTrade struct\n */\n function parseKyberTrade(\n bytes memory _tradesData,\n uint256 _offset\n )\n private\n pure\n returns (KyberTrade memory)\n {\n KyberTrade memory trade;\n\n uint256 tradeDataStart = _tradesData.contentAddress().add(_offset);\n\n assembly {\n mstore(trade, mload(tradeDataStart)) // destinationToken\n mstore(add(trade, 32), mload(add(tradeDataStart, 32))) // sourceToken\n mstore(add(trade, 64), mload(add(tradeDataStart, 64))) // sourceTokenQuantity\n mstore(add(trade, 96), mload(add(tradeDataStart, 96))) // minimumConversionRate\n mstore(add(trade, 128), mload(add(tradeDataStart, 128))) // maxDestinationQuantity\n }\n\n return trade;\n }\n}\n"
},
{
"path": "contracts/core/exchange-wrappers/ZeroExExchangeWrapper.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\nimport { ExchangeWrapperLibrary } from \"../lib/ExchangeWrapperLibrary.sol\";\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IExchange } from \"../../external/0x/Exchange/interfaces/IExchange.sol\";\nimport { LibBytes } from \"../../external/0x/LibBytes.sol\";\nimport { LibFillResults } from \"../../external/0x/Exchange/libs/LibFillResults.sol\";\nimport { LibOrder } from \"../../external/0x/Exchange/libs/LibOrder.sol\";\nimport { ZeroExOrderLibrary } from \"./lib/ZeroExOrderLibrary.sol\";\n\n\n/**\n * @title ZeroExExchangeWrapper\n * @author Set Protocol\n *\n * The ZeroExExchangeWrapper contract wrapper to interface with 0x V2\n */\ncontract ZeroExExchangeWrapper {\n using LibBytes for bytes;\n using SafeMath for uint256;\n\n /* ============ State Variables ============ */\n\n address public core;\n address public zeroExExchange;\n address public zeroExProxy;\n address public zeroExToken;\n address public setTransferProxy;\n\n /* ============ Constructor ============ */\n\n /**\n * Initialize exchange wrapper with required addresses to facilitate 0x orders\n *\n * @param _core Deployed Core contract\n * @param _zeroExExchange 0x Exchange contract for filling orders\n * @param _zeroExProxy 0x Proxy contract for transferring\n * @param _zeroExToken ZRX token contract addressed used for 0x relayer fees\n * @param _setTransferProxy Set Protocol transfer proxy contract\n */\n constructor(\n address _core,\n address _zeroExExchange,\n address _zeroExProxy,\n address _zeroExToken,\n address _setTransferProxy\n )\n public\n {\n core = _core;\n zeroExExchange = _zeroExExchange;\n zeroExProxy = _zeroExProxy;\n zeroExToken = _zeroExToken;\n setTransferProxy = _setTransferProxy;\n\n // Approve transfer of 0x token from this wrapper in the event of zeroExOrder relayer fees\n ERC20Wrapper.approve(\n _zeroExToken,\n _zeroExProxy,\n CommonMath.maxUInt256()\n );\n }\n\n /* ============ Public Functions ============ */\n\n /**\n * Parses 0x exchange orders and executes them for Set component tokens\n *\n *\n * @param _exchangeData Standard exchange wrapper interface object containing exchange metadata\n * @param _ordersData Arbitrary bytes data for any information to pass to the exchange\n * @return ExchangeWrapperLibrary.ExchangeResults Struct containing component acquisition results\n */\n function exchange(\n ExchangeWrapperLibrary.ExchangeData memory _exchangeData,\n bytes memory _ordersData\n )\n public\n returns (ExchangeWrapperLibrary.ExchangeResults memory)\n {\n require(\n ICore(core).validModules(msg.sender),\n \"ZeroExExchangeWrapper.exchange: Sender must be approved module\"\n );\n\n uint256 tradesCount = _exchangeData.orderCount;\n address[] memory sendTokens = new address[](tradesCount);\n address[] memory receiveTokens = new address[](tradesCount);\n uint256[] memory receiveTokenAmounts = new uint256[](tradesCount);\n\n uint256 scannedBytes = 0;\n for (uint256 i = 0; i < _exchangeData.orderCount; i++) {\n ZeroExOrderLibrary.ZeroExOrderInformation memory orderInformation;\n uint256 orderBodyStart;\n\n // Parse order i's information\n (orderInformation, orderBodyStart) = parseOrderInformation(\n _ordersData,\n scannedBytes\n );\n\n // Track the send tokens to ensure any leftovers are returned to the user\n sendTokens[i] = orderInformation.takerToken;\n\n // Fill the order via the 0x exchange\n (receiveTokens[i], receiveTokenAmounts[i]) = fillZeroExOrder(\n _exchangeData.caller,\n orderInformation\n );\n\n // Ensure the received token can be transfered via the Set transfer proxy\n ERC20Wrapper.ensureAllowance(\n receiveTokens[i],\n address(this),\n setTransferProxy,\n receiveTokenAmounts[i]\n );\n\n // Update current bytes\n scannedBytes = orderBodyStart.add(384);\n }\n\n // Return leftover send tokens to the original caller\n ExchangeWrapperLibrary.returnLeftoverSendTokens(\n sendTokens,\n _exchangeData.caller\n );\n\n return ExchangeWrapperLibrary.ExchangeResults({\n receiveTokens: receiveTokens,\n receiveTokenAmounts: receiveTokenAmounts\n });\n }\n\n /* ============ Private ============ */\n\n /**\n * Parses and executes 0x order from orders data bytes\n *\n * @param _caller Address of user issuing or redeeming using 0x orders\n * @param _orderInformation Object with parsed 0x order, signature, header, and maker/taker tokens\n * @return address Address of set component (0x makerToken) in 0x order\n * @return uint256 Amount of 0x order makerTokenAmount received\n */\n function fillZeroExOrder(\n address _caller,\n ZeroExOrderLibrary.ZeroExOrderInformation memory _orderInformation\n )\n private\n returns (address, uint256)\n {\n LibOrder.Order memory order = _orderInformation.order;\n ZeroExOrderLibrary.OrderHeader memory header = _orderInformation.header;\n\n // Ensure the taker token is allowed to be transferred by ZeroEx Proxy\n ERC20Wrapper.ensureAllowance(\n _orderInformation.takerToken,\n address(this),\n zeroExProxy,\n order.takerAssetAmount\n );\n\n // Calculate actual fill amount\n uint256 zeroExFillAmount = header.fillAmount;\n\n // Tranfer ZRX fee from taker if applicable\n if (order.takerFee > 0) {\n transferRelayerFee(\n order.takerFee,\n order.takerAssetAmount,\n _caller,\n zeroExFillAmount\n );\n }\n\n // Fill 0x order via their Exchange contract\n LibFillResults.FillResults memory fillResults = IExchange(zeroExExchange).fillOrKillOrder(\n order,\n zeroExFillAmount,\n header.signature\n );\n\n return (\n _orderInformation.makerToken,\n fillResults.makerAssetFilledAmount\n );\n }\n\n /**\n * Transfers fees from the caller to this wrapper in the event of taker relayer fees on the 0x order\n *\n * @param _takerFee Taker fee of the 0x order\n * @param _takerAssetAmount Taker asset of the original\n * @param _caller Address of original caller who is supploying ZRX\n * @param _fillAmount Amount of takerAssetAmount to fill to calculate partial fee\n */\n function transferRelayerFee(\n uint256 _takerFee,\n uint256 _takerAssetAmount,\n address _caller,\n uint256 _fillAmount\n )\n private\n {\n // Calculate amount of taker fee to transfer if fill quantity of 0x order is not for the full takerAssetAmount\n uint256 takerFeeToTransfer = CommonMath.getPartialAmount(\n _takerFee,\n _fillAmount,\n _takerAssetAmount\n );\n\n // Transfer ZRX from the caller to this wrapper\n ERC20Wrapper.transferFrom(\n zeroExToken,\n _caller,\n address(this),\n takerFeeToTransfer\n );\n }\n\n /**\n * Parses 0x order and returns order with offset in bytestring to parse next order\n *\n * @param _ordersData Arbitrary bytes data for any information to pass to the exchange\n * @param _offset Where to start the parsing of the _ordersData bytestring\n * @return ZeroExOrderInformation Object with parsed 0x order, signature, header, and maker/taker tokens\n * @return uint256 Tracks how many bytes in _ordersData have been parsed\n */\n function parseOrderInformation(\n bytes memory _ordersData,\n uint256 _offset\n )\n private\n pure\n returns (ZeroExOrderLibrary.ZeroExOrderInformation memory, uint256)\n {\n // Parse header of current wrapper order\n ZeroExOrderLibrary.OrderHeader memory header = ZeroExOrderLibrary.parseOrderHeader(\n _ordersData,\n _offset\n );\n\n // Helper to reduce math, keeping the position of the start of the next 0x order body\n uint256 orderBodyStart = _offset.add(header.signatureLength).add(64);\n\n // Grab signature of current wrapper order after the header of length 64 and before the start of the body\n header.signature = _ordersData.slice(\n _offset.add(64),\n orderBodyStart\n );\n\n // Parse 0x order of current wrapper order\n LibOrder.Order memory order = ZeroExOrderLibrary.parseZeroExOrder(_ordersData, orderBodyStart);\n address makerToken = ZeroExOrderLibrary.parseMakerTokenFromZeroExOrder(_ordersData, orderBodyStart);\n address takerToken = ZeroExOrderLibrary.parseTakerTokenFromZeroExOrder(_ordersData, orderBodyStart);\n\n ZeroExOrderLibrary.ZeroExOrderInformation memory orderInformation = ZeroExOrderLibrary.ZeroExOrderInformation({\n header: header,\n order: order,\n makerToken: makerToken,\n takerToken: takerToken\n });\n\n return (orderInformation, orderBodyStart);\n }\n}\n"
},
{
"path": "contracts/core/exchange-wrappers/lib/ZeroExOrderLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { LibBytes } from \"../../../external/0x/LibBytes.sol\";\nimport { LibOrder } from \"../../../external/0x/Exchange/libs/LibOrder.sol\";\n\n\n/**\n * @title ZeroExOrderLibrary\n * @author Set Protocol\n *\n * This library contains functions and structs to assist with parsing 0x wrapper order data\n *\n * The layout of each wrapper order is in the table below. \"ordersData\" always refers to one or more byte strings,\n * each containing all of these columns concatenated together. Each of the parse methods (header/body) below takes\n * the entire ordersData along with an offset to parse the next (header/body) specified by the offset. This saves\n * from having to do redudant memCopies to isolate the bytes containing the data to parse.\n *\n * | Section | Data | Offset | Length | Contents |\n * |---------|-----------------------|---------------------|-----------------|-------------------------------|\n * | Header | signatureLength | 0 | 32 | Num Bytes of 0x Signature |\n * | | fillAmount | 32 | 64 | Taker asset fill amouint |\n * | Body | signature | 64 | signatureLength | Signature in bytes |\n * | | order | 64+signatureLength | 384 | ZeroEx Order |\n */\nlibrary ZeroExOrderLibrary {\n using LibBytes for bytes;\n using SafeMath for uint256;\n\n // ============ Structs ============\n\n struct OrderHeader {\n uint256 signatureLength;\n uint256 fillAmount;\n bytes signature;\n }\n\n struct ZeroExOrderInformation {\n OrderHeader header;\n LibOrder.Order order;\n address makerToken;\n address takerToken;\n }\n\n // ============ Internal Functions ============\n\n /*\n * Parses the header from order byte array\n * Can only be called by authorized contracts.\n *\n * @param _ordersData Byte array of order data\n * @param _offset Offset to start scanning for order header\n * @return OrderHeader Struct containing wrapper order header data\n */\n function parseOrderHeader(\n bytes memory _ordersData,\n uint256 _offset\n )\n internal\n pure\n returns (OrderHeader memory)\n {\n OrderHeader memory header;\n\n uint256 orderDataStart = _ordersData.contentAddress().add(_offset);\n\n assembly {\n mstore(header, mload(orderDataStart)) // signatureLength\n mstore(add(header, 32), mload(add(orderDataStart, 32))) // fillAmount\n }\n\n return header;\n }\n\n /*\n * Parses the bytes array into ZeroEx order\n *\n * | Data | Location |\n * |----------------------------|-------------------------------|\n * | makerAddress | 0 |\n * | takerAddress | 32 |\n * | feeRecipientAddress | 64 |\n * | senderAddress | 96 |\n * | makerAssetAmount | 128 |\n * | takerAssetAmount | 160 |\n * | makerFee | 192 |\n * | takerFee | 224 |\n * | expirationTimeSeconds | 256 |\n * | salt | 288 |\n * | makerToken | 320 |\n * | takerToken | 352 |\n *\n * @param _ordersData Byte array of (multiple) 0x wrapper orders\n * @param _offset Offset to start scanning for 0x order body\n * @return LibOrder.Order 0x order struct\n */\n function parseZeroExOrder(\n bytes memory _ordersData,\n uint256 _offset\n )\n internal\n pure\n returns (LibOrder.Order memory)\n {\n LibOrder.Order memory order;\n address makerTokenAddress;\n address takerTokenAddress;\n\n uint256 orderDataStart = _ordersData.contentAddress().add(_offset);\n\n assembly {\n mstore(order, mload(orderDataStart)) // maker\n mstore(add(order, 32), mload(add(orderDataStart, 32))) // taker\n mstore(add(order, 64), mload(add(orderDataStart, 64))) // feeRecipient\n mstore(add(order, 96), mload(add(orderDataStart, 96))) // senderAddress\n mstore(add(order, 128), mload(add(orderDataStart, 128))) // makerAssetAmount\n mstore(add(order, 160), mload(add(orderDataStart, 160))) // takerAssetAmount\n mstore(add(order, 192), mload(add(orderDataStart, 192))) // makerFee\n mstore(add(order, 224), mload(add(orderDataStart, 224))) // takerFee\n mstore(add(order, 256), mload(add(orderDataStart, 256))) // expirationUnixTimestampSec\n mstore(add(order, 288), mload(add(orderDataStart, 288))) // salt\n makerTokenAddress := mload(add(orderDataStart, 320)) // makerToken\n takerTokenAddress := mload(add(orderDataStart, 352)) // takerToken\n }\n\n order.makerAssetData = tokenAddressToAssetData(makerTokenAddress);\n order.takerAssetData = tokenAddressToAssetData(takerTokenAddress);\n\n return order;\n }\n /*\n * Parses the maker token from the ZeroEx order\n *\n * @param _ordersData Byte array of (multiple) 0x wrapper orders\n * @param _offset Offset to start scanning for 0x order body\n * @return makerTokenAddress\n */\n function parseMakerTokenFromZeroExOrder(\n bytes memory _ordersData,\n uint256 _offset\n )\n internal\n pure\n returns (address)\n {\n address makerTokenAddress;\n\n uint256 orderDataStart = _ordersData.contentAddress().add(_offset);\n\n assembly {\n makerTokenAddress := mload(add(orderDataStart, 320)) // makerToken\n }\n\n return makerTokenAddress;\n }\n\n /*\n * Parses the taker token from the ZeroEx order\n *\n * @param _ordersData Byte array of (multiple) 0x wrapper orders\n * @param _offset Offset to start scanning for 0x order body\n * @return takerTokenAddress\n */\n function parseTakerTokenFromZeroExOrder(\n bytes memory _ordersData,\n uint256 _offset\n )\n internal\n pure\n returns (address)\n {\n address takerTokenAddress;\n\n uint256 orderDataStart = _ordersData.contentAddress().add(_offset);\n\n assembly {\n takerTokenAddress := mload(add(orderDataStart, 352)) // takerToken\n }\n\n return takerTokenAddress;\n }\n\n /*\n * Encodes an ERC20 token address into 0x asset data\n *\n * @param _tokenAddress Address of token to encode into 0x asset data\n * @return bytes 0x asset data representation of a token\n */\n function tokenAddressToAssetData(\n address _tokenAddress\n )\n private\n pure\n returns (bytes memory)\n {\n bytes memory result = new bytes(36);\n\n // padded version of bytes4(keccak256(\"ERC20Token(address)\"));\n bytes32 selector = 0xf47261b000000000000000000000000000000000000000000000000000000000;\n\n assembly {\n mstore(add(result, 32), selector)\n mstore(add(result, 36), _tokenAddress)\n }\n\n return result;\n }\n}\n"
},
{
"path": "contracts/core/extensions/CoreAccounting.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonValidationsLibrary } from \"set-protocol-contract-utils/contracts/lib/CommonValidationsLibrary.sol\";\n\nimport { CoreOperationState } from \"./CoreOperationState.sol\";\nimport { CoreState } from \"../lib/CoreState.sol\";\n\n\n/**\n * @title CoreAccounting\n * @author Set Protocol\n *\n * The CoreAccounting contract interfaces with the vault and transfer proxies for\n * storage of tokenized assets.\n */\ncontract CoreAccounting is\n CoreState,\n CoreOperationState,\n ReentrancyGuard\n{\n // Use SafeMath library for all uint256 arithmetic\n using SafeMath for uint256;\n\n /* ============ External Functions ============ */\n\n /**\n * Deposit a quantity of tokens to the vault and attribute to sender.\n *\n * @param _token Address of the token\n * @param _quantity Amount of tokens to deposit\n */\n function deposit(\n address _token,\n uint256 _quantity\n )\n external\n nonReentrant\n whenOperational\n {\n // Don't deposit if quantity <= 0\n if (_quantity > 0) {\n // Call TransferProxy contract to transfer user tokens to Vault\n state.transferProxyInstance.transfer(\n _token,\n _quantity,\n msg.sender,\n state.vault\n );\n\n // Call Vault contract to attribute deposited tokens to user\n state.vaultInstance.incrementTokenOwner(\n _token,\n msg.sender,\n _quantity\n );\n }\n }\n\n /**\n * Withdraw a quantity of tokens from the vault and deattribute from sender.\n *\n * @param _token Address of the token\n * @param _quantity Amount of tokens to withdraw\n */\n function withdraw(\n address _token,\n uint256 _quantity\n )\n external\n nonReentrant\n {\n // Don't withdraw if quantity <= 0\n if (_quantity > 0) {\n // Call Vault contract to deattribute withdrawn tokens from user\n state.vaultInstance.decrementTokenOwner(\n _token,\n msg.sender,\n _quantity\n );\n\n // Call Vault contract to withdraw tokens from Vault to user\n state.vaultInstance.withdrawTo(\n _token,\n msg.sender,\n _quantity\n );\n }\n }\n\n /**\n * Deposit multiple tokens to the vault and attribute to sender.\n * Quantities should be in the order of the addresses of the tokens being deposited.\n *\n * @param _tokens Array of the addresses of the tokens\n * @param _quantities Array of the amounts of tokens to deposit\n */\n function batchDeposit(\n address[] calldata _tokens,\n uint256[] calldata _quantities\n )\n external\n nonReentrant\n whenOperational\n {\n // Call internal batch deposit function\n batchDepositInternal(\n msg.sender,\n msg.sender,\n _tokens,\n _quantities\n );\n }\n\n /**\n * Withdraw multiple tokens from the vault and deattribute from sender.\n * Quantities should be in the order of the addresses of the tokens being withdrawn.\n *\n * @param _tokens Array of the addresses of the tokens\n * @param _quantities Array of the amounts of tokens to withdraw\n */\n function batchWithdraw(\n address[] calldata _tokens,\n uint256[] calldata _quantities\n )\n external\n nonReentrant\n {\n // Call internal batch withdraw function\n batchWithdrawInternal(\n msg.sender,\n msg.sender,\n _tokens,\n _quantities\n );\n }\n\n /**\n * Transfer tokens associated with the sender's account in vault to another user's\n * account in vault.\n *\n * @param _token Address of token being transferred\n * @param _to Address of user receiving tokens\n * @param _quantity Amount of tokens being transferred\n */\n function internalTransfer(\n address _token,\n address _to,\n uint256 _quantity\n )\n external\n nonReentrant\n whenOperational\n {\n state.vaultInstance.transferBalance(\n _token,\n msg.sender,\n _to,\n _quantity\n );\n }\n\n /* ============ Internal Functions ============ */\n\n /**\n * Internal function that deposits multiple tokens to the vault.\n * Quantities should be in the order of the addresses of the tokens being deposited.\n *\n * @param _from Address to transfer tokens from\n * @param _to Address to credit for deposits\n * @param _tokens Array of the addresses of the tokens being deposited\n * @param _quantities Array of the amounts of tokens to deposit\n */\n function batchDepositInternal(\n address _from,\n address _to,\n address[] memory _tokens,\n uint256[] memory _quantities\n )\n internal\n whenOperational\n {\n // Confirm an empty _tokens or quantity array is not passed\n CommonValidationsLibrary.validateNonEmpty(_tokens);\n\n // Confirm there is one quantity for every token address\n CommonValidationsLibrary.validateEqualLength(_tokens, _quantities);\n\n state.transferProxyInstance.batchTransfer(\n _tokens,\n _quantities,\n _from,\n state.vault\n );\n\n state.vaultInstance.batchIncrementTokenOwner(\n _tokens,\n _to,\n _quantities\n );\n }\n\n /**\n * Internal function that withdraws multiple tokens from the vault.\n * Quantities should be in the order of the addresses of the tokens being withdrawn.\n *\n * @param _from Address to decredit for withdrawals\n * @param _to Address to transfer tokens to\n * @param _tokens Array of the addresses of the tokens being withdrawn\n * @param _quantities Array of the amounts of tokens to withdraw\n */\n function batchWithdrawInternal(\n address _from,\n address _to,\n address[] memory _tokens,\n uint256[] memory _quantities\n )\n internal\n {\n // Confirm an empty _tokens or quantity array is not passed\n CommonValidationsLibrary.validateNonEmpty(_tokens);\n\n // Confirm there is one quantity for every token address\n CommonValidationsLibrary.validateEqualLength(_tokens, _quantities);\n\n // Call Vault contract to deattribute withdrawn tokens from user\n state.vaultInstance.batchDecrementTokenOwner(\n _tokens,\n _from,\n _quantities\n );\n\n // Call Vault contract to withdraw tokens from Vault to user\n state.vaultInstance.batchWithdrawTo(\n _tokens,\n _to,\n _quantities\n );\n }\n}\n"
},
{
"path": "contracts/core/extensions/CoreAdmin.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { Ownable } from \"openzeppelin-solidity/contracts/ownership/Ownable.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\nimport { TimeLockUpgrade } from \"set-protocol-contract-utils/contracts/lib/TimeLockUpgrade.sol\";\n\nimport { CoreState } from \"../lib/CoreState.sol\";\n\n\n/**\n * @title CoreAdmin\n * @author Set Protocol\n *\n * The CoreAdmin contract contains methods to alter state of variables that track\n * Core dependency addresses.\n */\ncontract CoreAdmin is\n Ownable,\n CoreState,\n TimeLockUpgrade\n{\n using AddressArrayUtils for address[];\n\n /* ============ Events ============ */\n\n event FactoryAdded(\n address _factory\n );\n\n event FactoryRemoved(\n address _factory\n );\n\n event ExchangeAdded(\n uint8 _exchangeId,\n address _exchange\n );\n\n event ExchangeRemoved(\n uint8 _exchangeId\n );\n\n event ModuleAdded(\n address _module\n );\n\n event ModuleRemoved(\n address _module\n );\n\n event SetDisabled(\n address _set\n );\n\n event SetReenabled(\n address _set\n );\n\n event PriceLibraryAdded(\n address _priceLibrary\n );\n\n event PriceLibraryRemoved(\n address _priceLibrary\n );\n\n /* ============ External Functions ============ */\n\n /**\n * Add a factory from the mapping of tracked factories.\n * Can only be called by owner of Core.\n *\n * @param _factory Address of the factory conforming to ISetFactory\n */\n function addFactory(\n address _factory\n )\n external\n onlyOwner\n timeLockUpgrade\n {\n require(\n !state.validFactories[_factory]\n );\n\n state.validFactories[_factory] = true;\n\n state.factories = state.factories.append(_factory);\n\n emit FactoryAdded(\n _factory\n );\n }\n\n /**\n * Remove a factory from the mapping of tracked factories.\n * Can only be called by owner of Core.\n *\n * @param _factory Address of the factory conforming to ISetFactory\n */\n function removeFactory(\n address _factory\n )\n external\n onlyOwner\n {\n require(\n state.validFactories[_factory]\n );\n\n state.factories = state.factories.remove(_factory);\n\n state.validFactories[_factory] = false;\n\n emit FactoryRemoved(\n _factory\n );\n }\n\n /**\n * Add an exchange address with the mapping of tracked exchanges.\n * Can only be called by owner of Core.\n *\n * @param _exchangeId Enumeration of exchange within the mapping\n * @param _exchange Address of the exchange conforming to IExchangeWrapper\n */\n function addExchange(\n uint8 _exchangeId,\n address _exchange\n )\n external\n onlyOwner\n timeLockUpgrade\n {\n require(\n state.exchangeIds[_exchangeId] == address(0)\n );\n\n state.exchangeIds[_exchangeId] = _exchange;\n\n state.exchanges = state.exchanges.append(_exchange);\n\n emit ExchangeAdded(\n _exchangeId,\n _exchange\n );\n }\n\n /**\n * Remove an exchange address with the mapping of tracked exchanges.\n * Can only be called by owner of Core.\n *\n * @param _exchangeId Enumeration of exchange within the mapping\n * @param _exchange Address of the exchange conforming to IExchangeWrapper\n */\n function removeExchange(\n uint8 _exchangeId,\n address _exchange\n )\n external\n onlyOwner\n {\n require(\n state.exchangeIds[_exchangeId] != address(0) &&\n state.exchangeIds[_exchangeId] == _exchange\n );\n\n state.exchanges = state.exchanges.remove(_exchange);\n\n state.exchangeIds[_exchangeId] = address(0);\n\n emit ExchangeRemoved(\n _exchangeId\n );\n }\n\n /**\n * Add a module address with the mapping of tracked modules.\n * Can only be called by owner of Core.\n *\n * @param _module Address of the module\n */\n function addModule(\n address _module\n )\n external\n onlyOwner\n timeLockUpgrade\n {\n require(\n !state.validModules[_module]\n );\n\n state.validModules[_module] = true;\n\n state.modules = state.modules.append(_module);\n\n emit ModuleAdded(\n _module\n );\n }\n\n /**\n * Remove a module address with the mapping of tracked modules.\n * Can only be called by owner of Core.\n *\n * @param _module Enumeration of module within the mapping\n */\n function removeModule(\n address _module\n )\n external\n onlyOwner\n {\n require(\n state.validModules[_module]\n );\n\n state.modules = state.modules.remove(_module);\n\n state.validModules[_module] = false;\n\n emit ModuleRemoved(\n _module\n );\n }\n\n /**\n * Disables a Set from the mapping and array of tracked Sets.\n * Can only be called by owner of Core.\n *\n * @param _set Address of the Set\n */\n function disableSet(\n address _set\n )\n external\n onlyOwner\n {\n require(\n state.validSets[_set]\n );\n\n state.setTokens = state.setTokens.remove(_set);\n\n state.validSets[_set] = false;\n\n state.disabledSets[_set] = true;\n\n emit SetDisabled(\n _set\n );\n }\n\n /**\n * Enables a Set from the mapping and array of tracked Sets if it has been previously disabled\n * Can only be called by owner of Core.\n *\n * @param _set Address of the Set\n */\n function reenableSet(\n address _set\n )\n external\n onlyOwner\n {\n require(\n state.disabledSets[_set]\n );\n\n state.setTokens = state.setTokens.append(_set);\n\n state.validSets[_set] = true;\n\n state.disabledSets[_set] = false;\n\n emit SetReenabled(\n _set\n );\n }\n\n /**\n * Add a price library from the mapping of tracked price libraries.\n * Can only be called by owner of Core.\n *\n * @param _priceLibrary Address of the price library\n */\n function addPriceLibrary(\n address _priceLibrary\n )\n external\n onlyOwner\n timeLockUpgrade\n {\n require(\n !state.validPriceLibraries[_priceLibrary]\n );\n\n state.validPriceLibraries[_priceLibrary] = true;\n\n state.priceLibraries = state.priceLibraries.append(_priceLibrary);\n\n emit PriceLibraryAdded(\n _priceLibrary\n );\n }\n\n /**\n * Remove a price library from the mapping of tracked price libraries.\n * Can only be called by owner of Core.\n *\n * @param _priceLibrary Address of the price library\n */\n function removePriceLibrary(\n address _priceLibrary\n )\n external\n onlyOwner\n {\n require(\n state.validPriceLibraries[_priceLibrary]\n );\n\n state.priceLibraries = state.priceLibraries.remove(_priceLibrary);\n\n state.validPriceLibraries[_priceLibrary] = false;\n\n emit PriceLibraryRemoved(\n _priceLibrary\n );\n }\n}\n"
},
{
"path": "contracts/core/extensions/CoreFactory.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { CoreState } from \"../lib/CoreState.sol\";\nimport { ISetFactory } from \"../interfaces/ISetFactory.sol\";\n\n\n/**\n * @title CoreFactory\n * @author Set Protocol\n *\n * The CoreFactory contract contains Set Token creation operations\n */\ncontract CoreFactory is\n CoreState\n{\n /* ============ Events ============ */\n\n event SetTokenCreated(\n address indexed _setTokenAddress,\n address _factory,\n address[] _components,\n uint256[] _units,\n uint256 _naturalUnit,\n bytes32 _name,\n bytes32 _symbol\n );\n\n /* ============ External Functions ============ */\n\n /**\n * Deploys a new Set Token and adds it to the valid list of SetTokens\n *\n * @param _factory The address of the Factory to create from\n * @param _components The address of component tokens\n * @param _units The units of each component token\n * @param _naturalUnit The minimum unit to be issued or redeemed\n * @param _name The bytes32 encoded name of the new Set\n * @param _symbol The bytes32 encoded symbol of the new Set\n * @param _callData Byte string containing additional call parameters\n * @return setTokenAddress The address of the new Set\n */\n function createSet(\n address _factory,\n address[] calldata _components,\n uint256[] calldata _units,\n uint256 _naturalUnit,\n bytes32 _name,\n bytes32 _symbol,\n bytes calldata _callData\n )\n external\n returns (address)\n {\n // Verify Factory is linked to Core\n require(\n state.validFactories[_factory],\n \"CreateSet\"\n );\n\n // Create the Set\n address newSetTokenAddress = ISetFactory(_factory).createSet(\n _components,\n _units,\n _naturalUnit,\n _name,\n _symbol,\n _callData\n );\n\n // Add Set to the mapping of tracked Sets\n state.validSets[newSetTokenAddress] = true;\n\n // Add Set to the array of tracked Sets\n state.setTokens.push(newSetTokenAddress);\n\n // Emit Set Token creation log\n emit SetTokenCreated(\n newSetTokenAddress,\n _factory,\n _components,\n _units,\n _naturalUnit,\n _name,\n _symbol\n );\n\n return newSetTokenAddress;\n }\n}\n"
},
{
"path": "contracts/core/extensions/CoreIssuance.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { CoreOperationState } from \"./CoreOperationState.sol\";\nimport { CoreState } from \"../lib/CoreState.sol\";\nimport { CoreIssuanceLibrary } from \"../lib/CoreIssuanceLibrary.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { SetTokenLibrary } from \"../lib/SetTokenLibrary.sol\";\n\n\n/**\n * @title CoreIssuance\n * @author Set Protocol\n *\n * The CoreIssuance contract contains function related to issuing and redeeming Sets.\n */\ncontract CoreIssuance is\n CoreState,\n CoreOperationState,\n ReentrancyGuard\n{\n // Use SafeMath library for all uint256 arithmetic\n using SafeMath for uint256;\n\n /* ============ Events ============ */\n\n event SetIssued(\n address _setAddress,\n uint256 _quantity\n );\n\n event SetRedeemed(\n address _setAddress,\n uint256 _quantity\n );\n\n /* ============ External Functions ============ */\n\n /**\n * Issues a specified Set for a specified quantity to the caller\n * using the caller's components from the wallet and vault.\n *\n * @param _set Address of the Set to issue\n * @param _quantity Number of tokens to issue\n */\n function issue(\n address _set,\n uint256 _quantity\n )\n external\n nonReentrant\n {\n issueInternal(\n msg.sender,\n msg.sender,\n _set,\n _quantity\n );\n }\n\n /**\n * Converts user's components into Set Tokens owned by the user and stored in Vault\n *\n * @param _set Address of the Set\n * @param _quantity Number of tokens to redeem\n */\n function issueInVault(\n address _set,\n uint256 _quantity\n )\n external\n nonReentrant\n {\n issueInVaultInternal(\n msg.sender,\n _set,\n _quantity\n );\n }\n\n /**\n * Issues a specified Set for a specified quantity to the recipient\n * using the caller's components from the wallet and vault.\n *\n * @param _recipient Address to issue to\n * @param _set Address of the Set to issue\n * @param _quantity Number of tokens to issue\n */\n function issueTo(\n address _recipient,\n address _set,\n uint256 _quantity\n )\n external\n nonReentrant\n {\n issueInternal(\n msg.sender,\n _recipient,\n _set,\n _quantity\n );\n }\n\n /**\n * Exchange Set tokens for underlying components to the user held in the Vault.\n *\n * @param _set Address of the Set to redeem\n * @param _quantity Number of tokens to redeem\n */\n function redeem(\n address _set,\n uint256 _quantity\n )\n external\n nonReentrant\n {\n redeemInternal(\n msg.sender,\n msg.sender,\n _set,\n _quantity\n );\n }\n\n /**\n * Composite method to redeem and withdraw with a single transaction\n *\n * Normally, you should expect to be able to withdraw all of the tokens.\n * However, some have central abilities to freeze transfers (e.g. EOS). _toExclude\n * allows you to optionally specify which component tokens to exclude when\n * redeeming. They will remain in the vault under the users' addresses.\n *\n * @param _set Address of the Set\n * @param _to Address to withdraw or attribute tokens to\n * @param _quantity Number of tokens to redeem\n * @param _toExclude Mask of indexes of tokens to exclude from withdrawing\n */\n function redeemAndWithdrawTo(\n address _set,\n address _to,\n uint256 _quantity,\n uint256 _toExclude\n )\n external\n nonReentrant\n {\n uint256[] memory componentTransferValues = redeemAndDecrementVault(\n _set,\n msg.sender,\n _quantity\n );\n\n // Calculate the withdraw and increment quantities to specified address\n uint256[] memory incrementTokenOwnerValues;\n uint256[] memory withdrawToValues;\n (\n incrementTokenOwnerValues,\n withdrawToValues\n ) = CoreIssuanceLibrary.calculateWithdrawAndIncrementQuantities(\n componentTransferValues,\n _toExclude\n );\n\n address[] memory components = ISetToken(_set).getComponents();\n\n // Increment excluded components to the specified address\n state.vaultInstance.batchIncrementTokenOwner(\n components,\n _to,\n incrementTokenOwnerValues\n );\n\n // Withdraw non-excluded components and attribute to specified address\n state.vaultInstance.batchWithdrawTo(\n components,\n _to,\n withdrawToValues\n );\n }\n\n /**\n * Convert the caller's Set tokens held in the vault into underlying components to the user\n * held in the Vault.\n *\n * @param _set Address of the Set\n * @param _quantity Number of tokens to redeem\n */\n function redeemInVault(\n address _set,\n uint256 _quantity\n )\n external\n nonReentrant\n {\n // Decrement ownership of Set token in the vault\n state.vaultInstance.decrementTokenOwner(\n _set,\n msg.sender,\n _quantity\n );\n\n redeemInternal(\n state.vault,\n msg.sender,\n _set,\n _quantity\n );\n }\n\n /**\n * Redeem Set token and return components to specified recipient. The components\n * are left in the vault after redemption in the recipient's name.\n *\n * @param _recipient Recipient of Set being issued\n * @param _set Address of the Set\n * @param _quantity Number of tokens to redeem\n */\n function redeemTo(\n address _recipient,\n address _set,\n uint256 _quantity\n )\n external\n nonReentrant\n {\n redeemInternal(\n msg.sender,\n _recipient,\n _set,\n _quantity\n );\n }\n\n /* ============ Internal Functions ============ */\n\n /**\n * Exchange components for Set tokens, accepting any owner\n * Used in issue, issueTo, and issueInVaultInternal\n * The tokens minted are held by the recipient specified in _setRecipient.\n *\n * @param _componentOwner Address to use tokens from\n * @param _setRecipient Address to issue Set to\n * @param _set Address of the Set to issue\n * @param _quantity Number of tokens to issue\n */\n function issueInternal(\n address _componentOwner,\n address _setRecipient,\n address _set,\n uint256 _quantity\n )\n internal\n whenOperational\n {\n // Verify Set was created by Core and is enabled\n require(\n state.validSets[_set],\n \"IssueInternal\"\n );\n\n // Validate quantity is multiple of natural unit\n SetTokenLibrary.isMultipleOfSetNaturalUnit(_set, _quantity);\n\n SetTokenLibrary.SetDetails memory setToken = SetTokenLibrary.getSetDetails(_set);\n\n // Calculate component quantities required to issue\n uint256[] memory requiredComponentQuantities = CoreIssuanceLibrary.calculateRequiredComponentQuantities(\n setToken.units,\n setToken.naturalUnit,\n _quantity\n );\n\n // Calculate the withdraw and increment quantities to caller\n uint256[] memory decrementTokenOwnerValues;\n uint256[] memory depositValues;\n (\n decrementTokenOwnerValues,\n depositValues\n ) = CoreIssuanceLibrary.calculateDepositAndDecrementQuantities(\n setToken.components,\n requiredComponentQuantities,\n _componentOwner,\n state.vault\n );\n\n // Decrement components used for issuance in vault\n state.vaultInstance.batchDecrementTokenOwner(\n setToken.components,\n _componentOwner,\n decrementTokenOwnerValues\n );\n\n // Deposit tokens used for issuance into vault\n state.transferProxyInstance.batchTransfer(\n setToken.components,\n depositValues,\n _componentOwner,\n state.vault\n );\n\n // Increment the vault balance of the set token for the components\n state.vaultInstance.batchIncrementTokenOwner(\n setToken.components,\n _set,\n requiredComponentQuantities\n );\n\n // Issue set token\n ISetToken(_set).mint(\n _setRecipient,\n _quantity\n );\n\n emit SetIssued(\n _set,\n _quantity\n );\n }\n\n /**\n * Converts recipient's components into Set Tokens held directly in Vault.\n * Used in issueInVault\n *\n * @param _recipient Address to issue to\n * @param _set Address of the Set\n * @param _quantity Number of tokens to issue\n */\n function issueInVaultInternal(\n address _recipient,\n address _set,\n uint256 _quantity\n )\n internal\n {\n issueInternal(\n _recipient,\n state.vault,\n _set,\n _quantity\n );\n\n // Increment ownership of Set token in the vault\n state.vaultInstance.incrementTokenOwner(\n _set,\n _recipient,\n _quantity\n );\n }\n\n /**\n * Exchange Set tokens for underlying components. Components are attributed in the vault.\n * Used in redeem, redeemInVault, and redeemTo\n *\n * @param _burnAddress Address to burn tokens from\n * @param _incrementAddress Address to increment component tokens to\n * @param _set Address of the Set to redeem\n * @param _quantity Number of tokens to redeem\n */\n function redeemInternal(\n address _burnAddress,\n address _incrementAddress,\n address _set,\n uint256 _quantity\n )\n internal\n {\n uint256[] memory componentQuantities = redeemAndDecrementVault(\n _set,\n _burnAddress,\n _quantity\n );\n\n // Increment the component amount\n address[] memory components = ISetToken(_set).getComponents();\n state.vaultInstance.batchIncrementTokenOwner(\n components,\n _incrementAddress,\n componentQuantities\n );\n }\n\n /**\n * Private method that validates inputs, redeems Set, and decrements\n * the components in the vault\n *\n * @param _set Address of the Set to redeem\n * @param _burnAddress Address to burn tokens from\n * @param _quantity Number of tokens to redeem \n * @return componentQuantities Transfer value of components\n */\n function redeemAndDecrementVault(\n address _set,\n address _burnAddress,\n uint256 _quantity\n )\n private\n returns (uint256[] memory)\n {\n // Verify Set was created by Core and is enabled\n require(\n state.validSets[_set],\n \"RedeemAndDecrementVault\"\n );\n\n // Validate quantity is multiple of natural unit\n SetTokenLibrary.isMultipleOfSetNaturalUnit(_set, _quantity);\n\n // Burn the Set token (thereby decrementing the Set balance)\n ISetToken(_set).burn(\n _burnAddress,\n _quantity\n );\n\n SetTokenLibrary.SetDetails memory setToken = SetTokenLibrary.getSetDetails(_set);\n\n // Calculate component quantities to redeem\n uint256[] memory componentQuantities = CoreIssuanceLibrary.calculateRequiredComponentQuantities(\n setToken.units,\n setToken.naturalUnit,\n _quantity\n );\n\n // Decrement components from Set's possession\n state.vaultInstance.batchDecrementTokenOwner(\n setToken.components,\n _set,\n componentQuantities\n );\n\n emit SetRedeemed(\n _set,\n _quantity\n );\n\n return componentQuantities;\n }\n}\n"
},
{
"path": "contracts/core/extensions/CoreModuleInteraction.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\n\nimport { CoreState } from \"../lib/CoreState.sol\";\nimport { ICoreAccounting } from \"../interfaces/ICoreAccounting.sol\";\nimport { ICoreIssuance } from \"../interfaces/ICoreIssuance.sol\";\n\n\n/**\n * @title CoreModularInteraction\n * @author Set Protocol\n *\n * Extension used to expose internal accounting and issuance functions, vault, and proxy functions\n * to modules.\n */\ncontract CoreModuleInteraction is\n ICoreAccounting,\n ICoreIssuance,\n CoreState,\n ReentrancyGuard\n{\n modifier onlyModule() {\n onlyModuleCallable();\n _;\n }\n\n function onlyModuleCallable() internal view {\n require(\n state.validModules[msg.sender],\n \"OnlyModule\"\n );\n }\n\n /**\n * Exposes internal function that deposits tokens to the vault, exposed to system\n * modules. Quantities should be in the order of the addresses of the tokens being\n * deposited.\n *\n * @param _from Address to transfer tokens from\n * @param _to Address to credit for deposits\n * @param _token Address of the token being deposited\n * @param _quantity Amount of tokens to deposit\n */\n function depositModule(\n address _from,\n address _to,\n address _token,\n uint256 _quantity\n )\n external\n onlyModule\n {\n address[] memory tokenArray = new address[](1);\n tokenArray[0] = _token;\n\n uint256[] memory quantityArray = new uint256[](1);\n quantityArray[0] = _quantity;\n\n batchDepositInternal(\n _from,\n _to,\n tokenArray,\n quantityArray\n );\n }\n\n /**\n * Exposes internal function that deposits multiple tokens to the vault, exposed to system\n * modules. Quantities should be in the order of the addresses of the tokens being\n * deposited.\n *\n * @param _from Address to transfer tokens from\n * @param _to Address to credit for deposits\n * @param _tokens Array of the addresses of the tokens being deposited\n * @param _quantities Array of the amounts of tokens to deposit\n */\n function batchDepositModule(\n address _from,\n address _to,\n address[] calldata _tokens,\n uint256[] calldata _quantities\n )\n external\n onlyModule\n {\n batchDepositInternal(\n _from,\n _to,\n _tokens,\n _quantities\n );\n }\n\n /**\n * Exposes internal function that withdraws multiple tokens to the vault, exposed to system\n * modules. Quantities should be in the order of the addresses of the tokens being\n * withdrawn.\n *\n * @param _from Address to decredit for withdrawals\n * @param _to Address to transfer tokens to\n * @param _token Address of the token being withdrawn\n * @param _quantity Amount of tokens to withdraw\n */\n function withdrawModule(\n address _from,\n address _to,\n address _token,\n uint256 _quantity\n )\n external\n onlyModule\n { \n address[] memory tokenArray = new address[](1);\n tokenArray[0] = _token;\n\n uint256[] memory quantityArray = new uint256[](1);\n quantityArray[0] = _quantity; \n\n batchWithdrawInternal(\n _from,\n _to,\n tokenArray,\n quantityArray\n );\n }\n\n /**\n * Exposes internal function that withdraws multiple tokens from the vault, to system\n * modules. Quantities should be in the order of the addresses of the tokens being withdrawn.\n *\n * @param _from Address to decredit for withdrawals\n * @param _to Address to transfer tokens to\n * @param _tokens Array of the addresses of the tokens being withdrawn\n * @param _quantities Array of the amounts of tokens to withdraw\n */\n function batchWithdrawModule(\n address _from,\n address _to,\n address[] calldata _tokens,\n uint256[] calldata _quantities\n )\n external\n onlyModule\n {\n batchWithdrawInternal(\n _from,\n _to,\n _tokens,\n _quantities\n );\n }\n\n /**\n * Expose internal function that exchanges components for Set tokens,\n * accepting any owner, to system modules\n *\n * @param _componentOwner Address to use tokens from\n * @param _setRecipient Address to issue Set to\n * @param _set Address of the Set to issue\n * @param _quantity Number of tokens to issue\n */\n function issueModule(\n address _componentOwner,\n address _setRecipient,\n address _set,\n uint256 _quantity\n )\n external\n onlyModule\n {\n issueInternal(\n _componentOwner,\n _setRecipient,\n _set,\n _quantity\n );\n }\n\n /**\n * Converts recipient's components into Set Token's held directly in Vault\n *\n * @param _recipient Address to issue to\n * @param _set Address of the Set\n * @param _quantity Number of tokens to redeem\n */\n function issueInVaultModule(\n address _recipient,\n address _set,\n uint256 _quantity\n )\n external\n onlyModule\n {\n issueInVaultInternal(\n _recipient,\n _set,\n _quantity\n );\n }\n\n /**\n * Expose internal function that exchanges Set tokens for components,\n * accepting any owner, to system modules\n *\n * @param _burnAddress Address to burn token from\n * @param _incrementAddress Address to increment component tokens to\n * @param _set Address of the Set to redeem\n * @param _quantity Number of tokens to redeem\n */\n function redeemModule(\n address _burnAddress,\n address _incrementAddress,\n address _set,\n uint256 _quantity\n )\n external\n onlyModule\n {\n redeemInternal(\n _burnAddress,\n _incrementAddress,\n _set,\n _quantity\n );\n }\n\n /**\n * Expose vault function that increments user's balance in the vault.\n * Available to system modules\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchIncrementTokenOwnerModule(\n address[] calldata _tokens,\n address _owner,\n uint256[] calldata _quantities\n )\n external\n onlyModule\n {\n state.vaultInstance.batchIncrementTokenOwner(\n _tokens,\n _owner,\n _quantities\n );\n }\n\n /**\n * Expose vault function that decrement user's balance in the vault\n * Only available to system modules.\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchDecrementTokenOwnerModule(\n address[] calldata _tokens,\n address _owner,\n uint256[] calldata _quantities\n )\n external\n onlyModule\n {\n state.vaultInstance.batchDecrementTokenOwner(\n _tokens,\n _owner,\n _quantities\n );\n }\n\n /**\n * Expose vault function that transfer vault balances between users\n * Only available to system modules.\n *\n * @param _tokens Addresses of tokens being transferred\n * @param _from Address tokens being transferred from\n * @param _to Address tokens being transferred to\n * @param _quantities Amounts of tokens being transferred\n */\n function batchTransferBalanceModule(\n address[] calldata _tokens,\n address _from,\n address _to,\n uint256[] calldata _quantities\n )\n external\n onlyModule\n {\n state.vaultInstance.batchTransferBalance(\n _tokens,\n _from,\n _to,\n _quantities\n );\n }\n\n /**\n * Transfers token from one address to another using the transfer proxy.\n * Only available to system modules.\n *\n * @param _token The address of the ERC20 token\n * @param _quantity The number of tokens to transfer\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n */\n function transferModule(\n address _token,\n uint256 _quantity,\n address _from,\n address _to\n )\n external\n onlyModule\n {\n state.transferProxyInstance.transfer(\n _token,\n _quantity,\n _from,\n _to\n );\n }\n\n /**\n * Expose transfer proxy function to transfer tokens from one address to another\n * Only available to system modules.\n *\n * @param _tokens The addresses of the ERC20 token\n * @param _quantities The numbers of tokens to transfer\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n */\n function batchTransferModule(\n address[] calldata _tokens,\n uint256[] calldata _quantities,\n address _from,\n address _to\n )\n external\n onlyModule\n {\n state.transferProxyInstance.batchTransfer(\n _tokens,\n _quantities,\n _from,\n _to\n );\n }\n}\n"
},
{
"path": "contracts/core/extensions/CoreOperationState.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { Ownable } from \"openzeppelin-solidity/contracts/ownership/Ownable.sol\";\n\nimport { CoreState } from \"../lib/CoreState.sol\";\n\n\n/**\n * @title CoreOperationState\n * @author Set Protocol\n *\n * The CoreOperationState contract contains methods to alter state of variables that track\n * Core dependency addresses.\n */\ncontract CoreOperationState is\n Ownable,\n CoreState\n{\n\n /* ============ Enum ============ */\n\n /**\n * Operational:\n * All Accounting and Issuance related functions are available for usage during this stage\n *\n * Shut Down:\n * Only functions which allow users to redeem and withdraw funds are allowed during this stage\n */\n enum OperationState {\n Operational,\n ShutDown,\n InvalidState\n }\n\n /* ============ Events ============ */\n\n event OperationStateChanged(\n uint8 _prevState,\n uint8 _newState\n );\n\n /* ============ Modifiers ============ */\n\n modifier whenOperational() {\n require(\n state.operationState == uint8(OperationState.Operational),\n \"WhenOperational\"\n );\n _;\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Updates the operation state of the protocol.\n * Can only be called by owner of Core.\n *\n * @param _operationState Uint8 representing the current protocol operation state\n */\n function setOperationState(\n uint8 _operationState\n )\n external\n onlyOwner\n {\n require(\n _operationState < uint8(OperationState.InvalidState) &&\n _operationState != state.operationState,\n \"InvalidOperationState\"\n );\n\n emit OperationStateChanged(\n state.operationState,\n _operationState\n );\n\n state.operationState = _operationState;\n }\n}\n"
},
{
"path": "contracts/core/fee-calculators/FixedFeeCalculator.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\nimport { ScaleValidations } from \"set-protocol-contract-utils/contracts/lib/ScaleValidations.sol\";\n\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IFeeCalculator } from \"../interfaces/IFeeCalculator.sol\";\nimport { SetTokenLibrary } from \"../lib/SetTokenLibrary.sol\";\n\n\n/**\n * @title FixedFeeCalculator\n * @author Set Protocol\n *\n * Smart contract that stores and returns fees (represented as scaled decimal values).\n * Meant to be used with a RebalancingSetTokenV2\n */\ncontract FixedFeeCalculator is IFeeCalculator {\n using SafeMath for uint256;\n\n /* ============ State Variables ============ */\n\n // Mapping between an address and its initialization state\n mapping(address => bool) public isInitialized;\n\n // Mapping between an address and its current fee\n mapping(address => uint256) public fees;\n\n /* ============ External Functions ============ */\n\n /**\n * Initializes the rebalance fee for the caller. Fee is represented as a scaled decimal value.\n * (e.g. 1% = 10 ** 18, 0.1% = 10 ** 17)\n * Intended to be called by a RebalancingSetTokenV2 during initialization.\n *\n * @param _feeCalculatorData Bytes encoded data about the fee for the sender\n */\n function initialize(\n bytes calldata _feeCalculatorData\n )\n external\n {\n // Sender fee must not already be initialized\n require(!isInitialized[msg.sender], \"Must not be initialized\");\n\n uint256 fee = parseFeeCalculatorData(_feeCalculatorData);\n\n validateFee(fee);\n \n fees[msg.sender] = fee;\n isInitialized[msg.sender] = true;\n }\n\n /**\n * Returns the fee initialized by the sender. Implicitly returns 0 if the fee has not bee initialized.\n */\n function getFee()\n external\n view\n returns(uint256)\n {\n return fees[msg.sender];\n }\n\n /**\n * Same as getFee, but a non-view function.\n */\n function updateAndGetFee()\n external\n returns(uint256)\n {\n return fees[msg.sender];\n }\n\n /*\n * Validate then set new streaming fee.\n *\n * @param _newFeePercentage Fee type and new streaming fee encoded in bytes\n */\n function adjustFee(\n bytes calldata _newFeePercentage\n )\n external\n {\n fees[msg.sender] = parseFeeCalculatorData(_newFeePercentage);\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Fee should not exceed 100% and should be a multiple of a basis point.\n *\n * @param _fee Fee value represented as scaled value\n */\n function validateFee(\n uint256 _fee\n )\n private\n view\n {\n ScaleValidations.validateLessThanEqualOneHundredPercent(_fee);\n \n ScaleValidations.validateMultipleOfBasisPoint(_fee);\n }\n\n /**\n * Function to convert the feeCalculator bytes data to the fee\n *\n * @param _feeCalculatorData Bytes encoded data about the fee for the sender\n * @return _fee Parsed fee value represented as scaled value\n */\n function parseFeeCalculatorData(\n bytes memory _feeCalculatorData\n )\n private\n pure\n returns (uint256)\n {\n uint256 fee;\n\n assembly {\n fee := mload(add(_feeCalculatorData, 32))\n }\n\n return fee;\n }\n}\n"
},
{
"path": "contracts/core/fee-calculators/PerformanceFeeCalculator.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental ABIEncoderV2;\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\nimport { ScaleValidations } from \"set-protocol-contract-utils/contracts/lib/ScaleValidations.sol\";\n\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IFeeCalculator } from \"../interfaces/IFeeCalculator.sol\";\nimport { IOracleWhiteList } from \"../interfaces/IOracleWhiteList.sol\";\nimport { IRebalancingSetTokenV2 } from \"../interfaces/IRebalancingSetTokenV2.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { PerformanceFeeLibrary } from \"./lib/PerformanceFeeLibrary.sol\";\nimport { SetUSDValuation } from \"../liquidators/impl/SetUSDValuation.sol\";\n\n\n/**\n * @title PerformanceFeeCalculator\n * @author Set Protocol\n *\n * Smart contract that stores and returns fees (represented as scaled decimal values). Fees are\n * determined based on performance of the Set and a streaming fee. Set values can be denominated\n * in any any asset based on oracle white list used in deploy.\n *\n * CHANGELOG:\n * - 5/17/2020: Update adjustFee function to update high watermark to prevent unexpected fee actualizations\n * when the profitFee was initially 0. We also disallow changing the profit fee if the the fee period\n * has not elapsed.\n */\ncontract PerformanceFeeCalculator is IFeeCalculator {\n\n using SafeMath for uint256;\n using CommonMath for uint256;\n\n /* ============ Enums ============ */\n\n enum FeeType { StreamingFee, ProfitFee }\n\n /* ============ Events ============ */\n\n event FeeActualization(\n address indexed rebalancingSetToken,\n uint256 newHighWatermark,\n uint256 profitFee,\n uint256 streamingFee\n );\n\n event FeeInitialization(\n address indexed rebalancingSetToken,\n uint256 profitFeePeriod,\n uint256 highWatermarkResetPeriod,\n uint256 profitFeePercentage,\n uint256 streamingFeePercentage,\n uint256 highWatermark,\n uint256 lastProfitFeeTimestamp,\n uint256 lastStreamingFeeTimestamp\n );\n\n event FeeAdjustment(\n address indexed rebalancingSetToken,\n FeeType feeType,\n uint256 newFeePercentage\n );\n\n /* ============ Structs ============ */\n\n struct InitFeeParameters {\n uint256 profitFeePeriod;\n uint256 highWatermarkResetPeriod;\n uint256 profitFeePercentage;\n uint256 streamingFeePercentage;\n }\n\n /* ============ Constants ============ */\n // 365.25 days used to represent the year\n uint256 private constant ONE_YEAR_IN_SECONDS = 365.25 days;\n uint256 private constant ONE_HUNDRED_PERCENT = 1e18;\n uint256 private constant ZERO = 0;\n\n /* ============ State Variables ============ */\n ICore public core;\n IOracleWhiteList public oracleWhiteList;\n uint256 public maximumProfitFeePercentage;\n uint256 public maximumStreamingFeePercentage;\n mapping(address => PerformanceFeeLibrary.FeeState) public feeState;\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for PerformanceFeeCalculator\n *\n * @param _core Core instance\n * @param _oracleWhiteList Oracle white list instance\n * @param _maximumProfitFeePercentage Maximum percent of profit fee scaled by 1e18\n * (e.g. 100% = 1e18 and 1% = 1e16)\n * @param _maximumStreamingFeePercentage Maximum percent of streaming fee scaled by 1e18\n * (e.g. 100% = 1e18 and 1% = 1e16)\n */\n constructor(\n ICore _core,\n IOracleWhiteList _oracleWhiteList,\n uint256 _maximumProfitFeePercentage,\n uint256 _maximumStreamingFeePercentage\n )\n public\n {\n core = _core;\n oracleWhiteList = _oracleWhiteList;\n maximumProfitFeePercentage = _maximumProfitFeePercentage;\n maximumStreamingFeePercentage = _maximumStreamingFeePercentage;\n }\n\n /* ============ External Functions ============ */\n\n /*\n * Called by RebalancingSetToken, parses bytedata then assigns to correct FeeState struct.\n *\n * @param _feeCalculatorData Bytestring encoding fee parameters for RebalancingSetToken\n */\n function initialize(\n bytes calldata _feeCalculatorData\n )\n external\n {\n // Parse fee data into struct\n InitFeeParameters memory parameters = parsePerformanceFeeCallData(_feeCalculatorData);\n\n // Validate fee data\n validateFeeParameters(parameters);\n uint256 highWatermark = SetUSDValuation.calculateRebalancingSetValue(msg.sender, oracleWhiteList);\n\n // Set fee state for new caller\n PerformanceFeeLibrary.FeeState storage feeInfo = feeState[msg.sender];\n\n feeInfo.profitFeePeriod = parameters.profitFeePeriod;\n feeInfo.highWatermarkResetPeriod = parameters.highWatermarkResetPeriod;\n feeInfo.profitFeePercentage = parameters.profitFeePercentage;\n feeInfo.streamingFeePercentage = parameters.streamingFeePercentage;\n feeInfo.lastProfitFeeTimestamp = block.timestamp;\n feeInfo.lastStreamingFeeTimestamp = block.timestamp;\n feeInfo.highWatermark = highWatermark;\n\n emit FeeInitialization(\n msg.sender,\n parameters.profitFeePeriod,\n parameters.highWatermarkResetPeriod,\n parameters.profitFeePercentage,\n parameters.streamingFeePercentage,\n highWatermark,\n block.timestamp,\n block.timestamp\n );\n }\n\n /*\n * Calculates total inflation percentage in order to accrue fees to manager. Profit fee calculations\n * are net of streaming fees, so streaming fees are applied first then profit fees are calculated.\n *\n * @return uint256 Percent inflation of supply\n */\n function getFee()\n external\n view\n returns (uint256)\n {\n (\n uint256 streamingFee,\n uint256 profitFee\n ) = calculateFees(msg.sender);\n\n return streamingFee.add(profitFee);\n }\n\n /**\n * Returns calculated streaming and profit fee.\n *\n * @param _setAddress Address of Set to get fees\n * @return uint256 Streaming Fee\n * @return uint256 Profit Fee\n */\n function getCalculatedFees(\n address _setAddress\n )\n external\n view\n returns (uint256, uint256)\n {\n (\n uint256 streamingFee,\n uint256 profitFee\n ) = calculateFees(_setAddress);\n\n return (streamingFee, profitFee);\n }\n\n /*\n * Calculates total inflation percentage in order to accrue fees to manager. Profit fee calculations\n * are net of streaming fees, so streaming fees are applied first then profit fees are calculated.\n * Additionally, fee state is set timestamps are updated for each fee type and the high watermark is\n * reset if time since last profit fee exceeds the highWatermarkResetPeriod.\n *\n * @return uint256 Percent inflation of supply\n */\n function updateAndGetFee()\n external\n returns (uint256)\n {\n (\n uint256 streamingFee,\n uint256 profitFee\n ) = calculateFees(msg.sender);\n\n // Update fee state based off fees collected\n updateFeeState(msg.sender, streamingFee, profitFee);\n\n emit FeeActualization(\n msg.sender,\n highWatermark(msg.sender),\n profitFee,\n streamingFee\n );\n\n return streamingFee.add(profitFee);\n }\n\n /*\n * Validate then set new streaming fee.\n *\n * @param _newFeeData Fee type and new streaming fee encoded in bytes\n */\n function adjustFee(\n bytes calldata _newFeeData\n )\n external\n {\n (\n FeeType feeIdentifier,\n uint256 feePercentage\n ) = parseNewFeeCallData(_newFeeData);\n\n // Since only two fee options and anything feeType integer passed that is not 0 or 1 will revert in\n // parsing can make this a simple if...else... statement\n if (feeIdentifier == FeeType.StreamingFee) {\n validateStreamingFeePercentage(feePercentage);\n\n feeState[msg.sender].streamingFeePercentage = feePercentage;\n } else {\n validateProfitFeePercentage(feePercentage);\n\n // IMPORTANT: In the case that a profit fee is initially 0 and is set to a non-zero number,\n // the actualizeFee / updateFeeState function does not update the high watermark\n // Thus, we need to reset the high water mark here so that users do not pay for profit fees\n // since inception.\n uint256 rebalancingSetValue = SetUSDValuation.calculateRebalancingSetValue(msg.sender, oracleWhiteList);\n uint256 existingHighwatermark = feeState[msg.sender].highWatermark;\n if (rebalancingSetValue > existingHighwatermark) {\n // In the case the profit fee period hasn't elapsed, disallow changing fees\n require(\n exceedsProfitFeePeriod(msg.sender),\n \"PerformanceFeeCalculator.adjustFee: ProfitFeePeriod must have elapsed to update fee\"\n );\n\n feeState[msg.sender].lastProfitFeeTimestamp = block.timestamp;\n feeState[msg.sender].highWatermark = rebalancingSetValue;\n }\n\n feeState[msg.sender].profitFeePercentage = feePercentage;\n }\n\n emit FeeAdjustment(msg.sender, feeIdentifier, feePercentage);\n }\n\n /* ============ Internal Functions ============ */\n\n /**\n * Updates fee state after a fee has been accrued. Streaming timestamp is always updated. Profit timestamp\n * is only updated if profit fee is collected. High watermark timestamp is updated if profit fee collected\n * or if a highWatermarkResetPeriod amount of time has passed since last profit fee collection.\n *\n * @param _setAddress Address of Set to have feeState updated\n * @param _streamingFee Calculated streaming fee percentage\n * @param _profitFee Calculated profit fee percentage\n */\n function updateFeeState(\n address _setAddress,\n uint256 _streamingFee,\n uint256 _profitFee\n )\n internal\n {\n // Set streaming fee timestamp\n feeState[_setAddress].lastStreamingFeeTimestamp = block.timestamp;\n\n uint256 rebalancingSetValue = SetUSDValuation.calculateRebalancingSetValue(_setAddress, oracleWhiteList);\n uint256 postStreamingValue = calculatePostStreamingValue(rebalancingSetValue, _streamingFee);\n\n // If profit fee then set new high watermark and profit fee timestamp\n if (_profitFee > 0) {\n feeState[_setAddress].lastProfitFeeTimestamp = block.timestamp;\n feeState[_setAddress].highWatermark = postStreamingValue;\n } else if (timeSinceLastProfitFee(_setAddress) >= highWatermarkResetPeriod(_setAddress)) {\n // If no profit fee and last profit fee was more than highWatermarkResetPeriod seconds ago then reset\n // high watermark\n feeState[_setAddress].highWatermark = postStreamingValue;\n feeState[_setAddress].lastProfitFeeTimestamp = block.timestamp;\n }\n }\n\n /*\n * Validates fee parameters. Ensures that both fees are below the max fee percentages and that they are\n * multiples of a basis point. Also makes sure highWatermarkResetPeriod is greater than profitFeePeriod.\n */\n function validateFeeParameters(\n InitFeeParameters memory parameters\n )\n internal\n view\n {\n // Validate fee amounts\n validateStreamingFeePercentage(parameters.streamingFeePercentage);\n validateProfitFeePercentage(parameters.profitFeePercentage);\n\n // WARNING: This require has downstream effects on security assumptions for updating and accruing fees.\n // Removing it allows highWatermarks to be reset, potentially cancelling fee collections or allowing traders\n // to apply higher profitFee to Set gains.\n require(\n parameters.highWatermarkResetPeriod >= parameters.profitFeePeriod,\n \"PerformanceFeeCalculator.validateFeeParameters: Fee collection frequency must exceed highWatermark reset.\"\n );\n }\n\n /*\n * Validates streaming fee is less than maximum allowed and multiple of basis point.\n */\n function validateStreamingFeePercentage(\n uint256 _streamingFee\n )\n internal\n view\n {\n require(\n _streamingFee <= maximumStreamingFeePercentage,\n \"PerformanceFeeCalculator.validateStreamingFeePercentage: Streaming fee exceeds maximum.\"\n );\n\n ScaleValidations.validateMultipleOfBasisPoint(_streamingFee);\n }\n\n /*\n * Validates profit fee is less than maximum allowed and multiple of basis point.\n */\n function validateProfitFeePercentage(\n uint256 _profitFee\n )\n internal\n view\n {\n require(\n _profitFee <= maximumProfitFeePercentage,\n \"PerformanceFeeCalculator.validateProfitFeePercentage: Profit fee exceeds maximum.\"\n );\n\n ScaleValidations.validateMultipleOfBasisPoint(_profitFee);\n }\n\n /**\n * Verifies caller is valid Set. Calculates and returns streaming and profit fee.\n *\n * @param _setAddress Address of Set to have feeState updated\n * @return uint256 Streaming Fee\n * @return uint256 Profit Fee\n */\n function calculateFees(\n address _setAddress\n )\n internal\n view\n returns (uint256, uint256)\n {\n require(\n core.validSets(_setAddress),\n \"PerformanceFeeCalculator.calculateFees: Caller must be valid RebalancingSetToken.\"\n );\n\n uint256 streamingFee = calculateStreamingFee(_setAddress);\n\n uint256 profitFee = calculateProfitFee(_setAddress, streamingFee);\n\n return (streamingFee, profitFee);\n }\n\n /**\n * Calculates streaming fee by multiplying streamingFeePercentage by the elapsed amount of time since the last fee\n * was collected divided by one year in seconds, since the fee is a yearly fee.\n *\n * @param _setAddress Address of Set to have feeState updated\n * @return uint256 Streaming fee\n */\n function calculateStreamingFee(\n address _setAddress\n )\n internal\n view\n returns(uint256)\n {\n uint256 timeSinceLastFee = block.timestamp.sub(lastStreamingFeeTimestamp(_setAddress));\n\n // Streaming fee is streaming fee times years since last fee\n return timeSinceLastFee.mul(streamingFeePercentage(_setAddress)).div(ONE_YEAR_IN_SECONDS);\n }\n\n /**\n * Calculates profit fee net of streaming fee. Value of rebalancing Set is determined then streaming fee subtracted,\n * to get postStreamingValue. This value is compared to the highWatermark, if greater than highWatermark multiply by\n * profitFeePercentage and divide by rebalancingSetValue to get inflation from profit fees. If postStreamingValue does\n * not exceed highWatermark then return 0.\n *\n * @param _setAddress Address of Set to have feeState updated\n * @param _streamingFee Calculated streaming fee percentage\n * @return uint256 Streaming fee\n */\n function calculateProfitFee(\n address _setAddress,\n uint256 _streamingFee\n )\n internal\n view\n returns(uint256)\n {\n // If time since last profit fee exceeds profitFeePeriod then calculate profit fee else 0.\n if (exceedsProfitFeePeriod(_setAddress)) {\n // Calculate post streaming value and get high watermark\n uint256 rebalancingSetValue = SetUSDValuation.calculateRebalancingSetValue(_setAddress, oracleWhiteList);\n uint256 postStreamingValue = calculatePostStreamingValue(rebalancingSetValue, _streamingFee);\n uint256 highWatermark = highWatermark(_setAddress);\n\n // Subtract high watermark from post streaming fee value, unless less than 0 set to 0\n uint256 gainedValue = postStreamingValue > highWatermark ? postStreamingValue.sub(highWatermark) : 0;\n\n // Determine percent fee in terms of current rebalancing Set value\n return gainedValue.mul(profitFeePercentage(_setAddress)).div(rebalancingSetValue);\n } else {\n return 0;\n }\n }\n\n /**\n * Calculates Rebalancing Set Token value after streaming fees accounted for.\n *\n * @param _rebalancingSetValue Pre-fee value of Set\n * @param _streamingFee Calculated streaming fee percentage\n * @return uint256 Post streaming fee value\n */\n function calculatePostStreamingValue(\n uint256 _rebalancingSetValue,\n uint256 _streamingFee\n )\n internal\n view\n returns (uint256)\n {\n return _rebalancingSetValue.sub(_rebalancingSetValue.mul(_streamingFee).deScale());\n }\n\n /**\n * Checks if time since last profit fee exceeds profitFeePeriod\n *\n * @return bool\n */\n function exceedsProfitFeePeriod(address _set) internal view returns (bool) {\n return timeSinceLastProfitFee(_set) > profitFeePeriod(_set);\n }\n\n /**\n * Checks if time since last profit fee exceeds profitFeePeriod\n *\n * @return uint256 Time since last profit fee accrued\n */\n function timeSinceLastProfitFee(address _set) internal view returns (uint256) {\n return block.timestamp.sub(lastProfitFeeTimestamp(_set));\n }\n\n function lastStreamingFeeTimestamp(address _set) internal view returns (uint256) {\n return feeState[_set].lastStreamingFeeTimestamp;\n }\n\n function lastProfitFeeTimestamp(address _set) internal view returns (uint256) {\n return feeState[_set].lastProfitFeeTimestamp;\n }\n\n function streamingFeePercentage(address _set) internal view returns (uint256) {\n return feeState[_set].streamingFeePercentage;\n }\n\n function profitFeePercentage(address _set) internal view returns (uint256) {\n return feeState[_set].profitFeePercentage;\n }\n\n function profitFeePeriod(address _set) internal view returns (uint256) {\n return feeState[_set].profitFeePeriod;\n }\n\n function highWatermark(address _set) internal view returns(uint256) {\n return feeState[_set].highWatermark;\n }\n\n function highWatermarkResetPeriod(address _set) internal view returns(uint256) {\n return feeState[_set].highWatermarkResetPeriod;\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Parses passed in fee parameters from bytestring.\n *\n * | CallData | Location |\n * |------------------------------|-------------------------------|\n * | profitFeePeriod | 32 |\n * | highWatermarkResetPeriod | 64 |\n * | profitFeePercentage | 96 |\n * | streamingFeePercentage | 128 |\n *\n * @param _callData Byte string containing fee parameter data\n * @return feeParameters Fee parameters\n */\n function parsePerformanceFeeCallData(\n bytes memory _callData\n )\n private\n pure\n returns (InitFeeParameters memory)\n {\n return abi.decode (_callData, (InitFeeParameters));\n }\n\n /**\n * Parses passed in fee parameters from bytestring. If passed feeType number exceeds number of\n * enum items function will revert.\n *\n * | CallData | Location |\n * |------------------------------|-------------------------------|\n * | feeType | 32 |\n * | feePercentage | 64 |\n *\n * @param _callData Byte string containing fee parameter data\n * @return feeParameters Fee parameters\n */\n function parseNewFeeCallData(\n bytes memory _callData\n )\n private\n pure\n returns (FeeType, uint256)\n {\n (\n uint8 feeType,\n uint256 feePercentage\n ) = abi.decode (_callData, (uint8, uint256));\n\n require(\n feeType < 2,\n \"PerformanceFeeCalculator.parseNewFeeCallData: Fee type invalid\"\n );\n\n return (FeeType(feeType), feePercentage);\n }\n}"
},
{
"path": "contracts/core/fee-calculators/lib/PerformanceFeeLibrary.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title PerformanceFeeLibrary\n * @author Set Protocol\n *\n * The PerformanceFeeLibrary contains struct definition for feeState so it can\n * be used elsewhere.\n */\nlibrary PerformanceFeeLibrary {\n\n /* ============ Structs ============ */\n\n struct FeeState {\n uint256 profitFeePeriod; // Time required between accruing profit fees\n uint256 highWatermarkResetPeriod; // Time required after last profit fee to reset high watermark\n uint256 profitFeePercentage; // Percent of profits that accrue to manager\n uint256 streamingFeePercentage; // Percent of Set that accrues to manager each year\n uint256 highWatermark; // Value of Set at last profit fee accrual\n uint256 lastProfitFeeTimestamp; // Timestamp last profit fee was accrued\n uint256 lastStreamingFeeTimestamp; // Timestamp last streaming fee was accrued\n }\n}"
},
{
"path": "contracts/core/interfaces/IAddressToAddressWhiteList.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n/**\n * @title IAddressToAddressWhiteList\n * @author Set Protocol\n *\n * The IAddressToAddressWhiteList interface exposes the whitelist mapping to check components\n */\ninterface IAddressToAddressWhiteList {\n\n /* ============ External Functions ============ */\n\n /**\n * Returns value of key type address passed in (not in array form)\n *\n * @param _key Address to check\n * @return bool Whether passed in address is whitelisted\n */\n function whitelist(\n address _key\n )\n external\n view\n returns (address);\n\n /**\n * Verifies an array of addresses against the whitelist\n *\n * @param _keys Array of key type addresses to check if value exists\n * @return bool Whether all addresses in the list are whitelisted\n */\n function areValidAddresses(\n address[] calldata _keys\n )\n external\n view\n returns (bool);\n\n /**\n * Return array of value type addresses based on passed in key type addresses \n *\n * @param _key Array of key type addresses to get value type addresses for\n * @return address[] Array of value type addresses\n */\n function getValues(\n address[] calldata _key\n )\n external\n view\n returns (address[] memory);\n\n /**\n * Return value type address associated with a passed key type address \n *\n * @param _key Address of key type\n * @return address Address associated with _key \n */\n function getValue(\n address _key\n )\n external\n view\n returns (address);\n\n /**\n * Return array of all whitelisted addresses\n *\n * @return address[] Array of key type addresses\n */\n function validAddresses()\n external\n view\n returns (address[] memory);\n}\n"
},
{
"path": "contracts/core/interfaces/ICToken.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title ICToken\n * @author Set Protocol\n *\n * Interface for interacting with Compound cTokens\n */\ninterface ICToken {\n\n /**\n * Calculates the exchange rate from the underlying to the CToken\n *\n * @notice Accrue interest then return the up-to-date exchange rate\n * @return Calculated exchange rate scaled by 1e18\n */\n function exchangeRateCurrent()\n external\n returns (uint256);\n\n function exchangeRateStored() external view returns (uint256);\n\n function decimals() external view returns(uint8);\n\n /**\n * Sender supplies assets into the market and receives cTokens in exchange\n *\n * @notice Accrues interest whether or not the operation succeeds, unless reverted\n * @param mintAmount The amount of the underlying asset to supply\n * @return uint 0=success, otherwise a failure\n */\n function mint(uint mintAmount) external returns (uint);\n\n /**\n * @notice Sender redeems cTokens in exchange for the underlying asset\n * @dev Accrues interest whether or not the operation succeeds, unless reverted\n * @param redeemTokens The number of cTokens to redeem into underlying\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n */\n function redeem(uint redeemTokens) external returns (uint);\n}"
},
{
"path": "contracts/core/interfaces/ICore.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title ICore\n * @author Set Protocol\n *\n * The ICore Contract defines all the functions exposed in the Core through its\n * various extensions and is a light weight way to interact with the contract.\n */\ninterface ICore {\n /**\n * Return transferProxy address.\n *\n * @return address transferProxy address\n */\n function transferProxy()\n external\n view\n returns (address);\n\n /**\n * Return vault address.\n *\n * @return address vault address\n */\n function vault()\n external\n view\n returns (address);\n\n /**\n * Return address belonging to given exchangeId.\n *\n * @param _exchangeId ExchangeId number\n * @return address Address belonging to given exchangeId\n */\n function exchangeIds(\n uint8 _exchangeId\n )\n external\n view\n returns (address);\n\n /*\n * Returns if valid set\n *\n * @return bool Returns true if Set created through Core and isn't disabled\n */\n function validSets(address)\n external\n view\n returns (bool);\n\n /*\n * Returns if valid module\n *\n * @return bool Returns true if valid module\n */\n function validModules(address)\n external\n view\n returns (bool);\n\n /**\n * Return boolean indicating if address is a valid Rebalancing Price Library.\n *\n * @param _priceLibrary Price library address\n * @return bool Boolean indicating if valid Price Library\n */\n function validPriceLibraries(\n address _priceLibrary\n )\n external\n view\n returns (bool);\n\n /**\n * Exchanges components for Set Tokens\n *\n * @param _set Address of set to issue\n * @param _quantity Quantity of set to issue\n */\n function issue(\n address _set,\n uint256 _quantity\n )\n external;\n\n /**\n * Issues a specified Set for a specified quantity to the recipient\n * using the caller's components from the wallet and vault.\n *\n * @param _recipient Address to issue to\n * @param _set Address of the Set to issue\n * @param _quantity Number of tokens to issue\n */\n function issueTo(\n address _recipient,\n address _set,\n uint256 _quantity\n )\n external;\n\n /**\n * Converts user's components into Set Tokens held directly in Vault instead of user's account\n *\n * @param _set Address of the Set\n * @param _quantity Number of tokens to redeem\n */\n function issueInVault(\n address _set,\n uint256 _quantity\n )\n external;\n\n /**\n * Function to convert Set Tokens into underlying components\n *\n * @param _set The address of the Set token\n * @param _quantity The number of tokens to redeem. Should be multiple of natural unit.\n */\n function redeem(\n address _set,\n uint256 _quantity\n )\n external;\n\n /**\n * Redeem Set token and return components to specified recipient. The components\n * are left in the vault\n *\n * @param _recipient Recipient of Set being issued\n * @param _set Address of the Set\n * @param _quantity Number of tokens to redeem\n */\n function redeemTo(\n address _recipient,\n address _set,\n uint256 _quantity\n )\n external;\n\n /**\n * Function to convert Set Tokens held in vault into underlying components\n *\n * @param _set The address of the Set token\n * @param _quantity The number of tokens to redeem. Should be multiple of natural unit.\n */\n function redeemInVault(\n address _set,\n uint256 _quantity\n )\n external;\n\n /**\n * Composite method to redeem and withdraw with a single transaction\n *\n * Normally, you should expect to be able to withdraw all of the tokens.\n * However, some have central abilities to freeze transfers (e.g. EOS). _toExclude\n * allows you to optionally specify which component tokens to exclude when\n * redeeming. They will remain in the vault under the users' addresses.\n *\n * @param _set Address of the Set\n * @param _to Address to withdraw or attribute tokens to\n * @param _quantity Number of tokens to redeem\n * @param _toExclude Mask of indexes of tokens to exclude from withdrawing\n */\n function redeemAndWithdrawTo(\n address _set,\n address _to,\n uint256 _quantity,\n uint256 _toExclude\n )\n external;\n\n /**\n * Deposit multiple tokens to the vault. Quantities should be in the\n * order of the addresses of the tokens being deposited.\n *\n * @param _tokens Array of the addresses of the ERC20 tokens\n * @param _quantities Array of the number of tokens to deposit\n */\n function batchDeposit(\n address[] calldata _tokens,\n uint256[] calldata _quantities\n )\n external;\n\n /**\n * Withdraw multiple tokens from the vault. Quantities should be in the\n * order of the addresses of the tokens being withdrawn.\n *\n * @param _tokens Array of the addresses of the ERC20 tokens\n * @param _quantities Array of the number of tokens to withdraw\n */\n function batchWithdraw(\n address[] calldata _tokens,\n uint256[] calldata _quantities\n )\n external;\n\n /**\n * Deposit any quantity of tokens into the vault.\n *\n * @param _token The address of the ERC20 token\n * @param _quantity The number of tokens to deposit\n */\n function deposit(\n address _token,\n uint256 _quantity\n )\n external;\n\n /**\n * Withdraw a quantity of tokens from the vault.\n *\n * @param _token The address of the ERC20 token\n * @param _quantity The number of tokens to withdraw\n */\n function withdraw(\n address _token,\n uint256 _quantity\n )\n external;\n\n /**\n * Transfer tokens associated with the sender's account in vault to another user's\n * account in vault.\n *\n * @param _token Address of token being transferred\n * @param _to Address of user receiving tokens\n * @param _quantity Amount of tokens being transferred\n */\n function internalTransfer(\n address _token,\n address _to,\n uint256 _quantity\n )\n external;\n\n /**\n * Deploys a new Set Token and adds it to the valid list of SetTokens\n *\n * @param _factory The address of the Factory to create from\n * @param _components The address of component tokens\n * @param _units The units of each component token\n * @param _naturalUnit The minimum unit to be issued or redeemed\n * @param _name The bytes32 encoded name of the new Set\n * @param _symbol The bytes32 encoded symbol of the new Set\n * @param _callData Byte string containing additional call parameters\n * @return setTokenAddress The address of the new Set\n */\n function createSet(\n address _factory,\n address[] calldata _components,\n uint256[] calldata _units,\n uint256 _naturalUnit,\n bytes32 _name,\n bytes32 _symbol,\n bytes calldata _callData\n )\n external\n returns (address);\n\n /**\n * Exposes internal function that deposits a quantity of tokens to the vault and attributes\n * the tokens respectively, to system modules.\n *\n * @param _from Address to transfer tokens from\n * @param _to Address to credit for deposit\n * @param _token Address of token being deposited\n * @param _quantity Amount of tokens to deposit\n */\n function depositModule(\n address _from,\n address _to,\n address _token,\n uint256 _quantity\n )\n external;\n\n /**\n * Exposes internal function that withdraws a quantity of tokens from the vault and\n * deattributes the tokens respectively, to system modules.\n *\n * @param _from Address to decredit for withdraw\n * @param _to Address to transfer tokens to\n * @param _token Address of token being withdrawn\n * @param _quantity Amount of tokens to withdraw\n */\n function withdrawModule(\n address _from,\n address _to,\n address _token,\n uint256 _quantity\n )\n external;\n\n /**\n * Exposes internal function that deposits multiple tokens to the vault, to system\n * modules. Quantities should be in the order of the addresses of the tokens being\n * deposited.\n *\n * @param _from Address to transfer tokens from\n * @param _to Address to credit for deposits\n * @param _tokens Array of the addresses of the tokens being deposited\n * @param _quantities Array of the amounts of tokens to deposit\n */\n function batchDepositModule(\n address _from,\n address _to,\n address[] calldata _tokens,\n uint256[] calldata _quantities\n )\n external;\n\n /**\n * Exposes internal function that withdraws multiple tokens from the vault, to system\n * modules. Quantities should be in the order of the addresses of the tokens being withdrawn.\n *\n * @param _from Address to decredit for withdrawals\n * @param _to Address to transfer tokens to\n * @param _tokens Array of the addresses of the tokens being withdrawn\n * @param _quantities Array of the amounts of tokens to withdraw\n */\n function batchWithdrawModule(\n address _from,\n address _to,\n address[] calldata _tokens,\n uint256[] calldata _quantities\n )\n external;\n\n /**\n * Expose internal function that exchanges components for Set tokens,\n * accepting any owner, to system modules\n *\n * @param _owner Address to use tokens from\n * @param _recipient Address to issue Set to\n * @param _set Address of the Set to issue\n * @param _quantity Number of tokens to issue\n */\n function issueModule(\n address _owner,\n address _recipient,\n address _set,\n uint256 _quantity\n )\n external;\n\n /**\n * Expose internal function that exchanges Set tokens for components,\n * accepting any owner, to system modules\n *\n * @param _burnAddress Address to burn token from\n * @param _incrementAddress Address to increment component tokens to\n * @param _set Address of the Set to redeem\n * @param _quantity Number of tokens to redeem\n */\n function redeemModule(\n address _burnAddress,\n address _incrementAddress,\n address _set,\n uint256 _quantity\n )\n external;\n\n /**\n * Expose vault function that increments user's balance in the vault.\n * Available to system modules\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchIncrementTokenOwnerModule(\n address[] calldata _tokens,\n address _owner,\n uint256[] calldata _quantities\n )\n external;\n\n /**\n * Expose vault function that decrement user's balance in the vault\n * Only available to system modules.\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchDecrementTokenOwnerModule(\n address[] calldata _tokens,\n address _owner,\n uint256[] calldata _quantities\n )\n external;\n\n /**\n * Expose vault function that transfer vault balances between users\n * Only available to system modules.\n *\n * @param _tokens Addresses of tokens being transferred\n * @param _from Address tokens being transferred from\n * @param _to Address tokens being transferred to\n * @param _quantities Amounts of tokens being transferred\n */\n function batchTransferBalanceModule(\n address[] calldata _tokens,\n address _from,\n address _to,\n uint256[] calldata _quantities\n )\n external;\n\n /**\n * Transfers token from one address to another using the transfer proxy.\n * Only available to system modules.\n *\n * @param _token The address of the ERC20 token\n * @param _quantity The number of tokens to transfer\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n */\n function transferModule(\n address _token,\n uint256 _quantity,\n address _from,\n address _to\n )\n external;\n\n /**\n * Expose transfer proxy function to transfer tokens from one address to another\n * Only available to system modules.\n *\n * @param _tokens The addresses of the ERC20 token\n * @param _quantities The numbers of tokens to transfer\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n */\n function batchTransferModule(\n address[] calldata _tokens,\n uint256[] calldata _quantities,\n address _from,\n address _to\n )\n external;\n}\n"
},
{
"path": "contracts/core/interfaces/ICoreAccounting.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title ICoreAccounting\n * @author Set Protocol\n *\n * The ICoreAccounting Contract defines all the functions exposed in the CoreIssuance\n * extension.\n */\ncontract ICoreAccounting {\n\n /* ============ Internal Functions ============ */\n\n /**\n * Internal function that deposits multiple tokens to the vault.\n * Quantities should be in the order of the addresses of the tokens being deposited.\n *\n * @param _from Address to transfer tokens from\n * @param _to Address to credit for deposits\n * @param _tokens Array of the addresses of the tokens being deposited\n * @param _quantities Array of the amounts of tokens to deposit\n */\n function batchDepositInternal(\n address _from,\n address _to,\n address[] memory _tokens,\n uint[] memory _quantities\n )\n internal;\n\n /**\n * Internal function that withdraws multiple tokens from the vault.\n * Quantities should be in the order of the addresses of the tokens being withdrawn.\n *\n * @param _from Address to decredit for withdrawals\n * @param _to Address to transfer tokens to\n * @param _tokens Array of the addresses of the tokens being withdrawn\n * @param _quantities Array of the amounts of tokens to withdraw\n */\n function batchWithdrawInternal(\n address _from,\n address _to,\n address[] memory _tokens,\n uint256[] memory _quantities\n )\n internal;\n}\n"
},
{
"path": "contracts/core/interfaces/ICoreIssuance.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title ICoreIssuance\n * @author Set Protocol\n *\n * The ICoreIssuance Contract defines all the functions exposed in the CoreIssuance\n * extension.\n */\ncontract ICoreIssuance {\n\n /* ============ Internal Functions ============ */\n\n /**\n * Exchange components for Set tokens, accepting any owner\n *\n * @param _owner Address to use tokens from\n * @param _recipient Address to issue Set to\n * @param _set Address of the Set to issue\n * @param _quantity Number of tokens to issue\n */\n function issueInternal(\n address _owner,\n address _recipient,\n address _set,\n uint256 _quantity\n )\n internal;\n\n /**\n * Converts recipient's components into Set Tokens held directly in Vault\n *\n * @param _recipient Address to issue to\n * @param _set Address of the Set\n * @param _quantity Number of tokens to issue\n */\n function issueInVaultInternal(\n address _recipient,\n address _set,\n uint256 _quantity\n )\n internal;\n\n /**\n * Exchange Set tokens for underlying components\n *\n * @param _burnAddress Address to burn tokens from\n * @param _incrementAddress Address to increment component tokens to\n * @param _set Address of the Set to redeem\n * @param _quantity Number of tokens to redeem\n */\n function redeemInternal(\n address _burnAddress,\n address _incrementAddress,\n address _set,\n uint256 _quantity\n )\n internal;\n}\n"
},
{
"path": "contracts/core/interfaces/IExchangeIssuanceModule.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ExchangeIssuanceLibrary } from \"../modules/lib/ExchangeIssuanceLibrary.sol\";\n\n/**\n * @title IExchangeIssuanceModule\n * @author Set Protocol\n *\n * Interface for executing orders and issuing and redeeming a Set\n */\ninterface IExchangeIssuanceModule {\n\n function exchangeIssue(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams calldata _exchangeIssuanceParams,\n bytes calldata _orderData\n )\n external;\n\n\n function exchangeRedeem(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams calldata _exchangeIssuanceParams,\n bytes calldata _orderData\n )\n external;\n}\n"
},
{
"path": "contracts/core/interfaces/IExchangeWrapper.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ExchangeWrapperLibraryV2 } from \"../lib/ExchangeWrapperLibraryV2.sol\";\n\n/**\n * @title IExchangeWrapper\n * @author Set Protocol\n *\n * Interface for executing an order with an exchange wrapper\n */\ninterface IExchangeWrapper {\n\n /* ============ External Functions ============ */\n\n /**\n * Exchange some amount of makerToken for takerToken.\n *\n * maker Issuance order maker\n * taker Issuance order taker\n * makerToken Address of maker token used in exchange orders\n * makerAssetAmount Amount of issuance order maker token to use on this exchange\n * orderCount Expected number of orders to execute\n * fillQuantity Quantity of Set to be filled\n * attemptedFillQuantity Quantity of Set taker attempted to fill\n *\n * @param _orderData Arbitrary bytes data for any information to pass to the exchange\n */\n function exchange(\n ExchangeWrapperLibraryV2.ExchangeData calldata _exchangeData,\n bytes calldata _orderData\n )\n external\n returns (ExchangeWrapperLibraryV2.ExchangeResults memory);\n}\n"
},
{
"path": "contracts/core/interfaces/IFeeCalculator.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n/**\n * @title IFeeCalculator\n * @author Set Protocol\n *\n */\ninterface IFeeCalculator {\n\n /* ============ External Functions ============ */\n\n function initialize(\n bytes calldata _feeCalculatorData\n )\n external;\n\n function getFee()\n external\n view\n returns(uint256);\n\n function updateAndGetFee()\n external\n returns(uint256);\n\n function adjustFee(\n bytes calldata _newFeeData\n )\n external;\n}\n"
},
{
"path": "contracts/core/interfaces/ILiquidator.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ISetToken } from \"./ISetToken.sol\";\nimport { Rebalance } from \"../lib/Rebalance.sol\";\nimport { RebalancingLibrary } from \"../lib/RebalancingLibrary.sol\";\n\n/**\n * @title ILiquidator\n * @author Set Protocol\n *\n */\ninterface ILiquidator {\n\n /* ============ External Functions ============ */\n\n function startRebalance(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n bytes calldata _liquidatorData\n )\n external;\n\n function getBidPrice(\n address _set,\n uint256 _quantity\n )\n external\n view\n returns (Rebalance.TokenFlow memory);\n\n function placeBid(\n uint256 _quantity\n )\n external\n returns (Rebalance.TokenFlow memory);\n\n\n function settleRebalance()\n external;\n\n function endFailedRebalance() external;\n\n // ----------------------------------------------------------------------\n // Auction Price\n // ----------------------------------------------------------------------\n\n function auctionPriceParameters(address _set)\n external\n view\n returns (RebalancingLibrary.AuctionPriceParameters memory);\n\n // ----------------------------------------------------------------------\n // Auction\n // ----------------------------------------------------------------------\n\n function hasRebalanceFailed(address _set) external view returns (bool); \n function minimumBid(address _set) external view returns (uint256);\n function startingCurrentSets(address _set) external view returns (uint256);\n function remainingCurrentSets(address _set) external view returns (uint256);\n function getCombinedCurrentSetUnits(address _set) external view returns (uint256[] memory);\n function getCombinedNextSetUnits(address _set) external view returns (uint256[] memory);\n function getCombinedTokenArray(address _set) external view returns (address[] memory);\n}\n"
},
{
"path": "contracts/core/interfaces/IOracleWhiteList.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n/**\n * @title IOracleWhiteList\n * @author Set Protocol\n *\n * The IWhiteList interface exposes the whitelist mapping to check components\n */\ninterface IOracleWhiteList {\n\n /* ============ External Functions ============ */\n\n /**\n * Returns oracle of passed token address (not in array form)\n *\n * @param _tokenAddress Address to check\n * @return bool Whether passed in address is whitelisted\n */\n function oracleWhiteList(\n address _tokenAddress\n )\n external\n view\n returns (address);\n\n /**\n * Verifies an array of token addresses against the whitelist\n *\n * @param _addresses Array of addresses to verify\n * @return bool Whether all addresses in the list are whitelsited\n */\n function areValidAddresses(\n address[] calldata _addresses\n )\n external\n view\n returns (bool);\n\n /**\n * Return array of oracle addresses based on passed in token addresses \n *\n * @param _tokenAddresses Array of token addresses to get oracle addresses for\n * @return address[] Array of oracle addresses\n */\n function getOracleAddressesByToken(\n address[] calldata _tokenAddresses\n )\n external\n view\n returns (address[] memory);\n\n function getOracleAddressByToken(\n address _token\n )\n external\n view\n returns (address);\n}\n"
},
{
"path": "contracts/core/interfaces/IPerformanceFeeCalculator.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental ABIEncoderV2;\n\nimport { PerformanceFeeLibrary } from \"../fee-calculators/lib/PerformanceFeeLibrary.sol\";\n\n/**\n * @title IPerformanceFeeCalculator\n * @author Set Protocol\n *\n * Interface for accessing state on PerformanceFeeCalculator (function calls defined in IFeeCalculator)\n */\ninterface IPerformanceFeeCalculator {\n\n /* ============ External Functions ============ */\n\n function feeState(\n address _rebalancingSetToken\n )\n external\n view\n returns (PerformanceFeeLibrary.FeeState memory);\n\n function getCalculatedFees(\n address _setAddress\n )\n external\n view\n returns (uint256, uint256);\n}\n"
},
{
"path": "contracts/core/interfaces/IRebalanceAuctionModule.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\n/**\n * @title IRebalanceAuctionModule\n * @author Set Protocol\n *\n * The IRebalanceAuctionModule interface provides a light-weight, structured way to interact with the\n * RebalanceAuctionModule contract from another contract.\n */\n\ninterface IRebalanceAuctionModule {\n /**\n * Bid on rebalancing a given quantity of sets held by a rebalancing token\n * The tokens are returned to the user.\n *\n * @param _rebalancingSetToken Address of the rebalancing token being bid on\n * @param _quantity Number of currentSets to rebalance\n * @param _allowPartialFill Set to true if want to partially fill bid when quantity\n * is greater than currentRemainingSets\n */\n function bidAndWithdraw(\n address _rebalancingSetToken,\n uint256 _quantity,\n bool _allowPartialFill\n )\n external;\n}\n"
},
{
"path": "contracts/core/interfaces/IRebalancingSetFactory.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ISetFactory } from \"./ISetFactory.sol\";\nimport { IWhiteList } from \"./IWhiteList.sol\";\n\n\n/**\n * @title IRebalancingSetFactory\n * @author Set Protocol\n *\n * The IRebalancingSetFactory interface provides operability for authorized contracts\n * to interact with RebalancingSetTokenFactory\n */\ncontract IRebalancingSetFactory is\n ISetFactory\n{\n /**\n * Getter for minimumRebalanceInterval of RebalancingSetTokenFactory, used\n * to enforce rebalanceInterval when creating a RebalancingSetToken\n *\n * @return uint256 Minimum amount of time between rebalances in seconds\n */\n function minimumRebalanceInterval()\n external\n returns (uint256);\n\n /**\n * Getter for minimumProposalPeriod of RebalancingSetTokenFactory, used\n * to enforce proposalPeriod when creating a RebalancingSetToken\n *\n * @return uint256 Minimum amount of time users can review proposals in seconds\n */\n function minimumProposalPeriod()\n external\n returns (uint256);\n\n /**\n * Getter for minimumTimeToPivot of RebalancingSetTokenFactory, used\n * to enforce auctionTimeToPivot when proposing a rebalance\n *\n * @return uint256 Minimum amount of time before auction pivot reached\n */\n function minimumTimeToPivot()\n external\n returns (uint256);\n\n /**\n * Getter for maximumTimeToPivot of RebalancingSetTokenFactory, used\n * to enforce auctionTimeToPivot when proposing a rebalance\n *\n * @return uint256 Maximum amount of time before auction pivot reached\n */\n function maximumTimeToPivot()\n external\n returns (uint256);\n\n /**\n * Getter for minimumNaturalUnit of RebalancingSetTokenFactory\n *\n * @return uint256 Minimum natural unit\n */\n function minimumNaturalUnit()\n external\n returns (uint256);\n\n /**\n * Getter for maximumNaturalUnit of RebalancingSetTokenFactory\n *\n * @return uint256 Maximum Minimum natural unit\n */\n function maximumNaturalUnit()\n external\n returns (uint256);\n\n /**\n * Getter for rebalanceAuctionModule address on RebalancingSetTokenFactory\n *\n * @return address Address of rebalanceAuctionModule\n */\n function rebalanceAuctionModule()\n external\n returns (address);\n}\n"
},
{
"path": "contracts/core/interfaces/IRebalancingSetToken.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { RebalancingLibrary } from \"../lib/RebalancingLibrary.sol\";\n\n/**\n * @title IRebalancingSetToken\n * @author Set Protocol\n *\n * The IRebalancingSetToken interface provides a light-weight, structured way to interact with the\n * RebalancingSetToken contract from another contract.\n */\n\ninterface IRebalancingSetToken {\n\n /*\n * Get the auction library contract used for the current rebalance\n *\n * @return address Address of auction library used in the upcoming auction\n */\n function auctionLibrary()\n external\n view\n returns (address);\n\n /*\n * Get totalSupply of Rebalancing Set\n *\n * @return totalSupply\n */\n function totalSupply()\n external\n view\n returns (uint256);\n\n /*\n * Get proposalTimeStamp of Rebalancing Set\n *\n * @return proposalTimeStamp\n */\n function proposalStartTime()\n external\n view\n returns (uint256);\n\n /*\n * Get lastRebalanceTimestamp of Rebalancing Set\n *\n * @return lastRebalanceTimestamp\n */\n function lastRebalanceTimestamp()\n external\n view\n returns (uint256);\n\n /*\n * Get rebalanceInterval of Rebalancing Set\n *\n * @return rebalanceInterval\n */\n function rebalanceInterval()\n external\n view\n returns (uint256);\n\n /*\n * Get rebalanceState of Rebalancing Set\n *\n * @return RebalancingLibrary.State Current rebalance state of the RebalancingSetToken\n */\n function rebalanceState()\n external\n view\n returns (RebalancingLibrary.State);\n\n /*\n * Get the starting amount of current SetToken for the current auction\n *\n * @return rebalanceState\n */\n function startingCurrentSetAmount()\n external\n view\n returns (uint256);\n\n /**\n * Gets the balance of the specified address.\n *\n * @param owner The address to query the balance of.\n * @return A uint256 representing the amount owned by the passed address.\n */\n function balanceOf(\n address owner\n )\n external\n view\n returns (uint256);\n\n /**\n * Function used to set the terms of the next rebalance and start the proposal period\n *\n * @param _nextSet The Set to rebalance into\n * @param _auctionLibrary The library used to calculate the Dutch Auction price\n * @param _auctionTimeToPivot The amount of time for the auction to go ffrom start to pivot price\n * @param _auctionStartPrice The price to start the auction at\n * @param _auctionPivotPrice The price at which the price curve switches from linear to exponential\n */\n function propose(\n address _nextSet,\n address _auctionLibrary,\n uint256 _auctionTimeToPivot,\n uint256 _auctionStartPrice,\n uint256 _auctionPivotPrice\n )\n external;\n\n /*\n * Get natural unit of Set\n *\n * @return uint256 Natural unit of Set\n */\n function naturalUnit()\n external\n view\n returns (uint256);\n\n /**\n * Returns the address of the current base SetToken with the current allocation\n *\n * @return A address representing the base SetToken\n */\n function currentSet()\n external\n view\n returns (address);\n\n /**\n * Returns the address of the next base SetToken with the post auction allocation\n *\n * @return address Address representing the base SetToken\n */\n function nextSet()\n external\n view\n returns (address);\n\n /*\n * Get the unit shares of the rebalancing Set\n *\n * @return unitShares Unit Shares of the base Set\n */\n function unitShares()\n external\n view\n returns (uint256);\n\n /*\n * Burn set token for given address.\n * Can only be called by authorized contracts.\n *\n * @param _from The address of the redeeming account\n * @param _quantity The number of sets to burn from redeemer\n */\n function burn(\n address _from,\n uint256 _quantity\n )\n external;\n\n /*\n * Place bid during rebalance auction. Can only be called by Core.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return combinedTokenArray Array of token addresses invovled in rebalancing\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function placeBid(\n uint256 _quantity\n )\n external\n returns (address[] memory, uint256[] memory, uint256[] memory);\n\n /*\n * Get combinedTokenArray of Rebalancing Set\n *\n * @return combinedTokenArray\n */\n function getCombinedTokenArrayLength()\n external\n view\n returns (uint256);\n\n /*\n * Get combinedTokenArray of Rebalancing Set\n *\n * @return combinedTokenArray\n */\n function getCombinedTokenArray()\n external\n view\n returns (address[] memory);\n\n /*\n * Get failedAuctionWithdrawComponents of Rebalancing Set\n *\n * @return failedAuctionWithdrawComponents\n */\n function getFailedAuctionWithdrawComponents()\n external\n view\n returns (address[] memory);\n\n /*\n * Get auctionPriceParameters for current auction\n *\n * @return uint256[4] AuctionPriceParameters for current rebalance auction\n */\n function getAuctionPriceParameters()\n external\n view\n returns (uint256[] memory);\n\n /*\n * Get biddingParameters for current auction\n *\n * @return uint256[2] BiddingParameters for current rebalance auction\n */\n function getBiddingParameters()\n external\n view\n returns (uint256[] memory);\n\n /*\n * Get token inflows and outflows required for bid. Also the amount of Rebalancing\n * Sets that would be generated.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function getBidPrice(\n uint256 _quantity\n )\n external\n view\n returns (uint256[] memory, uint256[] memory);\n\n}\n"
},
{
"path": "contracts/core/interfaces/IRebalancingSetTokenV2.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { RebalancingLibrary } from \"../lib/RebalancingLibrary.sol\";\nimport { IFeeCalculator } from \"./IFeeCalculator.sol\";\nimport { ILiquidator } from \"./ILiquidator.sol\";\nimport { ISetToken } from \"./ISetToken.sol\";\n\n/**\n * @title IRebalancingSetTokenV2\n * @author Set Protocol\n *\n * The IRebalancingSetTokenV2 interface provides a light-weight, structured way to interact with the\n * RebalancingSetTokenV2 contract from another contract.\n */\n\ninterface IRebalancingSetTokenV2 {\n\n /*\n * Get totalSupply of Rebalancing Set\n *\n * @return totalSupply\n */\n function totalSupply()\n external\n view\n returns (uint256);\n\n /**\n * Returns liquidator instance\n *\n * @return ILiquidator Liquidator instance\n */\n function liquidator()\n external\n view\n returns (ILiquidator);\n\n /*\n * Get lastRebalanceTimestamp of Rebalancing Set\n *\n * @return lastRebalanceTimestamp\n */\n function lastRebalanceTimestamp()\n external\n view\n returns (uint256);\n\n /*\n * Get rebalanceStartTime of Rebalancing Set\n *\n * @return rebalanceStartTime\n */\n function rebalanceStartTime()\n external\n view\n returns (uint256);\n\n /*\n * Get startingCurrentSets of RebalancingSetToken\n *\n * @return startingCurrentSets\n */\n function startingCurrentSetAmount()\n external\n view\n returns (uint256);\n\n /*\n * Get rebalanceInterval of Rebalancing Set\n *\n * @return rebalanceInterval\n */\n function rebalanceInterval()\n external\n view\n returns (uint256);\n\n /*\n * Get array returning [startTime, timeToPivot, startPrice, endPrice] \n *\n * @return AuctionPriceParameters\n */\n function getAuctionPriceParameters() external view returns (uint256[] memory);\n\n /*\n * Get array returning [minimumBid, remainingCurrentSets] \n *\n * @return BiddingParameters\n */\n function getBiddingParameters() external view returns (uint256[] memory);\n\n /*\n * Get rebalanceState of Rebalancing Set\n *\n * @return RebalancingLibrary.State Current rebalance state of the RebalancingSetTokenV2\n */\n function rebalanceState()\n external\n view\n returns (RebalancingLibrary.State);\n\n /**\n * Gets the balance of the specified address.\n *\n * @param owner The address to query the balance of.\n * @return A uint256 representing the amount owned by the passed address.\n */\n function balanceOf(\n address owner\n )\n external\n view\n returns (uint256);\n\n /*\n * Get manager of Rebalancing Set\n *\n * @return manager\n */\n function manager()\n external\n view\n returns (address);\n\n /*\n * Get feeRecipient of Rebalancing Set\n *\n * @return feeRecipient\n */\n function feeRecipient()\n external\n view\n returns (address);\n\n /*\n * Get entryFee of Rebalancing Set\n *\n * @return entryFee\n */\n function entryFee()\n external\n view\n returns (uint256);\n\n /*\n * Retrieves the current expected fee from the fee calculator\n * Value is returned as a scale decimal figure.\n */\n function rebalanceFee()\n external\n view\n returns (uint256);\n\n /*\n * Get calculator contract used to compute rebalance fees\n *\n * @return rebalanceFeeCalculator\n */\n function rebalanceFeeCalculator()\n external\n view\n returns (IFeeCalculator);\n\n /*\n * Initializes the RebalancingSetToken. Typically called by the Factory during creation\n */\n function initialize(\n bytes calldata _rebalanceFeeCalldata\n )\n external;\n\n /*\n * Set new liquidator address. Only whitelisted addresses are valid.\n */\n function setLiquidator(\n ILiquidator _newLiquidator\n )\n external;\n\n /*\n * Set new fee recipient address.\n */\n function setFeeRecipient(\n address _newFeeRecipient\n )\n external;\n\n /*\n * Set new fee entry fee.\n */\n function setEntryFee(\n uint256 _newEntryFee\n )\n external;\n\n /*\n * Initiates the rebalance in coordination with the Liquidator contract. \n * In this step, we redeem the currentSet and pass relevant information\n * to the liquidator.\n *\n * @param _nextSet The Set to rebalance into\n * @param _liquidatorData Bytecode formatted data with liquidator-specific arguments\n *\n * Can only be called if the rebalance interval has elapsed.\n * Can only be called by manager.\n */\n function startRebalance(\n address _nextSet,\n bytes calldata _liquidatorData\n\n )\n external;\n\n /*\n * After a successful rebalance, the new Set is issued. If there is a rebalance fee,\n * the fee is paid via inflation of the Rebalancing Set to the feeRecipient.\n * Full issuance functionality is now returned to set owners.\n *\n * Anyone can call this function.\n */\n function settleRebalance()\n external;\n\n /*\n * Get natural unit of Set\n *\n * @return uint256 Natural unit of Set\n */\n function naturalUnit()\n external\n view\n returns (uint256);\n\n /**\n * Returns the address of the current base SetToken with the current allocation\n *\n * @return A address representing the base SetToken\n */\n function currentSet()\n external\n view\n returns (ISetToken);\n\n /**\n * Returns the address of the next base SetToken with the post auction allocation\n *\n * @return address Address representing the base SetToken\n */\n function nextSet()\n external\n view\n returns (ISetToken);\n\n /*\n * Get the unit shares of the rebalancing Set\n *\n * @return unitShares Unit Shares of the base Set\n */\n function unitShares()\n external\n view\n returns (uint256);\n\n /*\n * Place bid during rebalance auction. Can only be called by Core.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return combinedTokenArray Array of token addresses invovled in rebalancing\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function placeBid(\n uint256 _quantity\n )\n external\n returns (address[] memory, uint256[] memory, uint256[] memory);\n\n /*\n * Get token inflows and outflows required for bid. Also the amount of Rebalancing\n * Sets that would be generated.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function getBidPrice(\n uint256 _quantity\n )\n external\n view\n returns (uint256[] memory, uint256[] memory);\n\n /*\n * Get name of Rebalancing Set\n *\n * @return name\n */\n function name()\n external\n view\n returns (string memory);\n\n /*\n * Get symbol of Rebalancing Set\n *\n * @return symbol\n */\n function symbol()\n external\n view\n returns (string memory);\n}\n"
},
{
"path": "contracts/core/interfaces/IRebalancingSetTokenV3.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { RebalancingLibrary } from \"../lib/RebalancingLibrary.sol\";\nimport { IFeeCalculator } from \"./IFeeCalculator.sol\";\nimport { ILiquidator } from \"./ILiquidator.sol\";\nimport { ISetToken } from \"./ISetToken.sol\";\n\n/**\n * @title IRebalancingSetTokenV2\n * @author Set Protocol\n *\n * The IRebalancingSetTokenV3 interface provides a light-weight, structured way to interact with the\n * RebalancingSetTokenV3 contract from another contract.\n */\n\ninterface IRebalancingSetTokenV3 {\n\n /*\n * Get totalSupply of Rebalancing Set\n *\n * @return totalSupply\n */\n function totalSupply()\n external\n view\n returns (uint256);\n\n /**\n * Returns liquidator instance\n *\n * @return ILiquidator Liquidator instance\n */\n function liquidator()\n external\n view\n returns (ILiquidator);\n\n /*\n * Get lastRebalanceTimestamp of Rebalancing Set\n *\n * @return lastRebalanceTimestamp\n */\n function lastRebalanceTimestamp()\n external\n view\n returns (uint256);\n\n /*\n * Get rebalanceStartTime of Rebalancing Set\n *\n * @return rebalanceStartTime\n */\n function rebalanceStartTime()\n external\n view\n returns (uint256);\n\n /*\n * Get startingCurrentSets of RebalancingSetToken\n *\n * @return startingCurrentSets\n */\n function startingCurrentSetAmount()\n external\n view\n returns (uint256);\n\n /*\n * Get rebalanceInterval of Rebalancing Set\n *\n * @return rebalanceInterval\n */\n function rebalanceInterval()\n external\n view\n returns (uint256);\n\n /*\n * Get failAuctionPeriod of Rebalancing Set\n *\n * @return failAuctionPeriod\n */\n function rebalanceFailPeriod()\n external\n view\n returns (uint256);\n\n /*\n * Get array returning [startTime, timeToPivot, startPrice, endPrice]\n *\n * @return AuctionPriceParameters\n */\n function getAuctionPriceParameters() external view returns (uint256[] memory);\n\n /*\n * Get array returning [minimumBid, remainingCurrentSets]\n *\n * @return BiddingParameters\n */\n function getBiddingParameters() external view returns (uint256[] memory);\n\n /*\n * Get rebalanceState of Rebalancing Set\n *\n * @return RebalancingLibrary.State Current rebalance state of the RebalancingSetTokenV3\n */\n function rebalanceState()\n external\n view\n returns (RebalancingLibrary.State);\n\n /**\n * Gets the balance of the specified address.\n *\n * @param owner The address to query the balance of.\n * @return A uint256 representing the amount owned by the passed address.\n */\n function balanceOf(\n address owner\n )\n external\n view\n returns (uint256);\n\n /*\n * Get manager of Rebalancing Set\n *\n * @return manager\n */\n function manager()\n external\n view\n returns (address);\n\n /*\n * Get feeRecipient of Rebalancing Set\n *\n * @return feeRecipient\n */\n function feeRecipient()\n external\n view\n returns (address);\n\n /*\n * Get entryFee of Rebalancing Set\n *\n * @return entryFee\n */\n function entryFee()\n external\n view\n returns (uint256);\n\n /*\n * Retrieves the current expected fee from the fee calculator\n * Value is returned as a scale decimal figure.\n */\n function rebalanceFee()\n external\n view\n returns (uint256);\n\n /*\n * Get calculator contract used to compute rebalance fees\n *\n * @return rebalanceFeeCalculator\n */\n function rebalanceFeeCalculator()\n external\n view\n returns (IFeeCalculator);\n\n /*\n * Initializes the RebalancingSetToken. Typically called by the Factory during creation\n */\n function initialize(\n bytes calldata _rebalanceFeeCalldata\n )\n external;\n\n /*\n * Set new liquidator address. Only whitelisted addresses are valid.\n */\n function setLiquidator(\n ILiquidator _newLiquidator\n )\n external;\n\n /*\n * Set new manager address\n */\n function setManager(\n address _newManager\n )\n external;\n\n /*\n * Set new fee recipient address.\n */\n function setFeeRecipient(\n address _newFeeRecipient\n )\n external;\n\n /*\n * Set new fee entry fee.\n */\n function setEntryFee(\n uint256 _newEntryFee\n )\n external;\n\n /*\n * Initiates the rebalance in coordination with the Liquidator contract.\n * In this step, we redeem the currentSet and pass relevant information\n * to the liquidator.\n *\n * @param _nextSet The Set to rebalance into\n * @param _liquidatorData Bytecode formatted data with liquidator-specific arguments\n *\n * Can only be called if the rebalance interval has elapsed.\n * Can only be called by manager.\n */\n function startRebalance(\n address _nextSet,\n bytes calldata _liquidatorData\n\n )\n external;\n\n /*\n * After a successful rebalance, the new Set is issued. If there is a rebalance fee,\n * the fee is paid via inflation of the Rebalancing Set to the feeRecipient.\n * Full issuance functionality is now returned to set owners.\n *\n * Anyone can call this function.\n */\n function settleRebalance()\n external;\n\n /*\n * During the Default stage, the incentive / rebalance Fee can be triggered. This will\n * retrieve the current inflation fee from the fee calulator and mint the according\n * inflation to the feeRecipient. The unit shares is then adjusted based on the new\n * supply.\n *\n * Anyone can call this function.\n */\n function actualizeFee()\n external;\n\n /*\n * Validate then set new streaming fee.\n *\n * @param _newFeeData Fee type and new streaming fee encoded in bytes\n */\n function adjustFee(\n bytes calldata _newFeeData\n )\n external;\n\n /*\n * Get natural unit of Set\n *\n * @return uint256 Natural unit of Set\n */\n function naturalUnit()\n external\n view\n returns (uint256);\n\n /**\n * Returns the address of the current base SetToken with the current allocation\n *\n * @return A address representing the base SetToken\n */\n function currentSet()\n external\n view\n returns (ISetToken);\n\n /**\n * Returns the address of the next base SetToken with the post auction allocation\n *\n * @return address Address representing the base SetToken\n */\n function nextSet()\n external\n view\n returns (ISetToken);\n\n /*\n * Get the unit shares of the rebalancing Set\n *\n * @return unitShares Unit Shares of the base Set\n */\n function unitShares()\n external\n view\n returns (uint256);\n\n /*\n * Place bid during rebalance auction. Can only be called by Core.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return combinedTokenArray Array of token addresses invovled in rebalancing\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function placeBid(\n uint256 _quantity\n )\n external\n returns (address[] memory, uint256[] memory, uint256[] memory);\n\n /*\n * Get token inflows and outflows required for bid. Also the amount of Rebalancing\n * Sets that would be generated.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function getBidPrice(\n uint256 _quantity\n )\n external\n view\n returns (uint256[] memory, uint256[] memory);\n\n /*\n * Get name of Rebalancing Set\n *\n * @return name\n */\n function name()\n external\n view\n returns (string memory);\n\n /*\n * Get symbol of Rebalancing Set\n *\n * @return symbol\n */\n function symbol()\n external\n view\n returns (string memory);\n}\n"
},
{
"path": "contracts/core/interfaces/ISetFactory.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title ISetFactory\n * @author Set Protocol\n *\n * The ISetFactory interface provides operability for authorized contracts\n * to interact with SetTokenFactory\n */\ninterface ISetFactory {\n\n /* ============ External Functions ============ */\n\n /**\n * Return core address\n *\n * @return address core address\n */\n function core()\n external\n returns (address);\n\n /**\n * Deploys a new Set Token and adds it to the valid list of SetTokens\n *\n * @param _components The address of component tokens\n * @param _units The units of each component token\n * @param _naturalUnit The minimum unit to be issued or redeemed\n * @param _name The bytes32 encoded name of the new Set\n * @param _symbol The bytes32 encoded symbol of the new Set\n * @param _callData Byte string containing additional call parameters\n * @return setTokenAddress The address of the new Set\n */\n function createSet(\n address[] calldata _components,\n uint[] calldata _units,\n uint256 _naturalUnit,\n bytes32 _name,\n bytes32 _symbol,\n bytes calldata _callData\n )\n external\n returns (address);\n}\n"
},
{
"path": "contracts/core/interfaces/ISetToken.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n/**\n * @title ISetToken\n * @author Set Protocol\n *\n * The ISetToken interface provides a light-weight, structured way to interact with the\n * SetToken contract from another contract.\n */\ninterface ISetToken {\n\n /* ============ External Functions ============ */\n\n /*\n * Get natural unit of Set\n *\n * @return uint256 Natural unit of Set\n */\n function naturalUnit()\n external\n view\n returns (uint256);\n\n /*\n * Get addresses of all components in the Set\n *\n * @return componentAddresses Array of component tokens\n */\n function getComponents()\n external\n view\n returns (address[] memory);\n\n /*\n * Get units of all tokens in Set\n *\n * @return units Array of component units\n */\n function getUnits()\n external\n view\n returns (uint256[] memory);\n\n /*\n * Checks to make sure token is component of Set\n *\n * @param _tokenAddress Address of token being checked\n * @return bool True if token is component of Set\n */\n function tokenIsComponent(\n address _tokenAddress\n )\n external\n view\n returns (bool);\n\n /*\n * Mint set token for given address.\n * Can only be called by authorized contracts.\n *\n * @param _issuer The address of the issuing account\n * @param _quantity The number of sets to attribute to issuer\n */\n function mint(\n address _issuer,\n uint256 _quantity\n )\n external;\n\n /*\n * Burn set token for given address\n * Can only be called by authorized contracts\n *\n * @param _from The address of the redeeming account\n * @param _quantity The number of sets to burn from redeemer\n */\n function burn(\n address _from,\n uint256 _quantity\n )\n external;\n\n /**\n * Transfer token for a specified address\n *\n * @param to The address to transfer to.\n * @param value The amount to be transferred.\n */\n function transfer(\n address to,\n uint256 value\n )\n external;\n}\n"
},
{
"path": "contracts/core/interfaces/ITWAPAuctionGetters.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title ITWAPAuctionGetters\n * @author Set Protocol\n *\n * Interface for retrieving TWAPState struct\n */\ninterface ITWAPAuctionGetters {\n\n function getOrderSize(address _set) external view returns (uint256);\n\n function getOrderRemaining(address _set) external view returns (uint256);\n\n function getTotalSetsRemaining(address _set) external view returns (uint256);\n\n function getChunkSize(address _set) external view returns (uint256);\n\n function getChunkAuctionPeriod(address _set) external view returns (uint256);\n\n function getLastChunkAuctionEnd(address _set) external view returns (uint256);\n}\n"
},
{
"path": "contracts/core/interfaces/ITransferProxy.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n/**\n * @title ITransferProxy\n * @author Set Protocol\n *\n * The ITransferProxy interface provides a light-weight, structured way to interact with the\n * TransferProxy contract from another contract.\n */\ninterface ITransferProxy {\n\n /* ============ External Functions ============ */\n\n /**\n * Transfers tokens from an address (that has set allowance on the proxy).\n * Can only be called by authorized core contracts.\n *\n * @param _token The address of the ERC20 token\n * @param _quantity The number of tokens to transfer\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n */\n function transfer(\n address _token,\n uint256 _quantity,\n address _from,\n address _to\n )\n external;\n\n /**\n * Transfers tokens from an address (that has set allowance on the proxy).\n * Can only be called by authorized core contracts.\n *\n * @param _tokens The addresses of the ERC20 token\n * @param _quantities The numbers of tokens to transfer\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n */\n function batchTransfer(\n address[] calldata _tokens,\n uint256[] calldata _quantities,\n address _from,\n address _to\n )\n external;\n}\n"
},
{
"path": "contracts/core/interfaces/IVault.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n/**\n * @title IVault\n * @author Set Protocol\n *\n * The IVault interface provides a light-weight, structured way to interact with the Vault\n * contract from another contract.\n */\ninterface IVault {\n\n /*\n * Withdraws user's unassociated tokens to user account. Can only be\n * called by authorized core contracts.\n *\n * @param _token The address of the ERC20 token\n * @param _to The address to transfer token to\n * @param _quantity The number of tokens to transfer\n */\n function withdrawTo(\n address _token,\n address _to,\n uint256 _quantity\n )\n external;\n\n /*\n * Increment quantity owned of a token for a given address. Can\n * only be called by authorized core contracts.\n *\n * @param _token The address of the ERC20 token\n * @param _owner The address of the token owner\n * @param _quantity The number of tokens to attribute to owner\n */\n function incrementTokenOwner(\n address _token,\n address _owner,\n uint256 _quantity\n )\n external;\n\n /*\n * Decrement quantity owned of a token for a given address. Can only\n * be called by authorized core contracts.\n *\n * @param _token The address of the ERC20 token\n * @param _owner The address of the token owner\n * @param _quantity The number of tokens to deattribute to owner\n */\n function decrementTokenOwner(\n address _token,\n address _owner,\n uint256 _quantity\n )\n external;\n\n /**\n * Transfers tokens associated with one account to another account in the vault\n *\n * @param _token Address of token being transferred\n * @param _from Address token being transferred from\n * @param _to Address token being transferred to\n * @param _quantity Amount of tokens being transferred\n */\n\n function transferBalance(\n address _token,\n address _from,\n address _to,\n uint256 _quantity\n )\n external;\n\n\n /*\n * Withdraws user's unassociated tokens to user account. Can only be\n * called by authorized core contracts.\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchWithdrawTo(\n address[] calldata _tokens,\n address _to,\n uint256[] calldata _quantities\n )\n external;\n\n /*\n * Increment quantites owned of a collection of tokens for a given address. Can\n * only be called by authorized core contracts.\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchIncrementTokenOwner(\n address[] calldata _tokens,\n address _owner,\n uint256[] calldata _quantities\n )\n external;\n\n /*\n * Decrements quantites owned of a collection of tokens for a given address. Can\n * only be called by authorized core contracts.\n *\n * @param _tokens The addresses of the ERC20 tokens\n * @param _owner The address of the token owner\n * @param _quantities The numbers of tokens to attribute to owner\n */\n function batchDecrementTokenOwner(\n address[] calldata _tokens,\n address _owner,\n uint256[] calldata _quantities\n )\n external;\n\n /**\n * Transfers tokens associated with one account to another account in the vault\n *\n * @param _tokens Addresses of tokens being transferred\n * @param _from Address tokens being transferred from\n * @param _to Address tokens being transferred to\n * @param _quantities Amounts of tokens being transferred\n */\n function batchTransferBalance(\n address[] calldata _tokens,\n address _from,\n address _to,\n uint256[] calldata _quantities\n )\n external;\n\n /*\n * Get balance of particular contract for owner.\n *\n * @param _token The address of the ERC20 token\n * @param _owner The address of the token owner\n */\n function getOwnerBalance(\n address _token,\n address _owner\n )\n external\n view\n returns (uint256);\n}\n"
},
{
"path": "contracts/core/interfaces/IWhiteList.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n/**\n * @title IWhiteList\n * @author Set Protocol\n *\n * The IWhiteList interface exposes the whitelist mapping to check components\n */\ninterface IWhiteList {\n\n /* ============ External Functions ============ */\n\n /**\n * Validates address against white list\n *\n * @param _address Address to check\n * @return bool Whether passed in address is whitelisted\n */\n function whiteList(\n address _address\n )\n external\n view\n returns (bool);\n\n /**\n * Verifies an array of addresses against the whitelist\n *\n * @param _addresses Array of addresses to verify\n * @return bool Whether all addresses in the list are whitelsited\n */\n function areValidAddresses(\n address[] calldata _addresses\n )\n external\n view\n returns (bool);\n}\n"
},
{
"path": "contracts/core/lib/CoreIssuanceLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { IVault } from \"../interfaces/IVault.sol\";\n\n\n/**\n * @title CoreIssuanceLibrary\n * @author Set Protocol\n *\n * This library contains functions for calculating deposit, withdrawal,and transfer quantities\n */\nlibrary CoreIssuanceLibrary {\n\n using SafeMath for uint256;\n\n /**\n * Calculate the quantities required to deposit and decrement during issuance. Takes into account\n * the tokens an owner already has in the vault.\n *\n * @param _components Addresses of components\n * @param _componentQuantities Component quantities to increment and withdraw\n * @param _owner Address to deposit and decrement quantities from\n * @param _vault Address to vault\n * @return uint256[] decrementQuantities Quantities to decrement from vault\n * @return uint256[] depositQuantities Quantities to deposit into the vault\n */\n function calculateDepositAndDecrementQuantities(\n address[] calldata _components,\n uint256[] calldata _componentQuantities,\n address _owner,\n address _vault\n )\n external\n view\n returns (\n uint256[] memory /* decrementQuantities */,\n uint256[] memory /* depositQuantities */\n )\n {\n uint256 componentCount = _components.length;\n uint256[] memory decrementTokenOwnerValues = new uint256[](componentCount);\n uint256[] memory depositQuantities = new uint256[](componentCount);\n\n for (uint256 i = 0; i < componentCount; i++) {\n // Fetch component quantity in vault\n uint256 vaultBalance = IVault(_vault).getOwnerBalance(\n _components[i],\n _owner\n );\n\n // If the vault holds enough components, decrement the full amount\n if (vaultBalance >= _componentQuantities[i]) {\n decrementTokenOwnerValues[i] = _componentQuantities[i];\n } else {\n // User has less than required amount, decrement the vault by full balance\n if (vaultBalance > 0) {\n decrementTokenOwnerValues[i] = vaultBalance;\n }\n\n depositQuantities[i] = _componentQuantities[i].sub(vaultBalance);\n }\n }\n\n return (\n decrementTokenOwnerValues,\n depositQuantities\n );\n }\n\n /**\n * Calculate the quantities required to withdraw and increment during redeem and withdraw. Takes into\n * account a bitmask exclusion parameter.\n *\n * @param _componentQuantities Component quantities to increment and withdraw\n * @param _toExclude Mask of indexes of tokens to exclude from withdrawing\n * @return uint256[] incrementQuantities Quantities to increment in vault\n * @return uint256[] withdrawQuantities Quantities to withdraw from vault\n */\n function calculateWithdrawAndIncrementQuantities(\n uint256[] calldata _componentQuantities,\n uint256 _toExclude\n )\n external\n pure\n returns (\n uint256[] memory /* incrementQuantities */,\n uint256[] memory /* withdrawQuantities */\n )\n {\n uint256 componentCount = _componentQuantities.length;\n uint256[] memory incrementTokenOwnerValues = new uint256[](componentCount);\n uint256[] memory withdrawToValues = new uint256[](componentCount);\n\n // Loop through and decrement vault balances for the set, withdrawing if requested\n for (uint256 i = 0; i < componentCount; i++) {\n // Calculate bit index of current component\n uint256 componentBitIndex = CommonMath.safePower(2, i);\n\n // Transfer to user unless component index is included in _toExclude\n if ((_toExclude & componentBitIndex) != 0) {\n incrementTokenOwnerValues[i] = _componentQuantities[i];\n } else {\n withdrawToValues[i] = _componentQuantities[i];\n }\n }\n\n return (\n incrementTokenOwnerValues,\n withdrawToValues\n );\n }\n\n /**\n * Calculate the required component quantities required for issuance or rdemption for a given \n * quantity of Set Tokens\n *\n * @param _componentUnits The units of the component token\n * @param _naturalUnit The natural unit of the Set token\n * @param _quantity The number of tokens being redeem\n * @return uint256[] Required quantities in base units of components\n */\n function calculateRequiredComponentQuantities(\n uint256[] calldata _componentUnits,\n uint256 _naturalUnit,\n uint256 _quantity\n )\n external\n pure\n returns (uint256[] memory)\n {\n require(\n _quantity.mod(_naturalUnit) == 0,\n \"CoreIssuanceLibrary: Quantity must be a multiple of nat unit\"\n );\n\n uint256[] memory tokenValues = new uint256[](_componentUnits.length);\n\n // Transfer the underlying tokens to the corresponding token balances\n for (uint256 i = 0; i < _componentUnits.length; i++) {\n tokenValues[i] = _quantity.div(_naturalUnit).mul(_componentUnits[i]);\n }\n\n return tokenValues;\n }\n\n}\n"
},
{
"path": "contracts/core/lib/CoreState.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ITransferProxy } from \"../interfaces/ITransferProxy.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\n\n\n/**\n * @title CoreState\n * @author Set Protocol\n *\n * The CoreState library maintains all state for the Core contract thus\n * allowing it to operate across multiple mixins.\n */\ncontract CoreState {\n\n /* ============ Structs ============ */\n\n struct State {\n // Protocol state of operation\n uint8 operationState;\n\n // Address of the TransferProxy contract\n address transferProxy;\n\n // Address of the Vault contract\n address vault;\n\n // Instance of transferProxy contract\n ITransferProxy transferProxyInstance;\n\n // Instance of Vault Contract\n IVault vaultInstance;\n\n // Mapping of exchange enumeration to address\n mapping(uint8 => address) exchangeIds;\n\n // Mapping of approved modules\n mapping(address => bool) validModules;\n\n // Mapping of tracked SetToken factories\n mapping(address => bool) validFactories;\n\n // Mapping of tracked rebalancing price libraries\n mapping(address => bool) validPriceLibraries;\n\n // Mapping of tracked SetTokens\n mapping(address => bool) validSets;\n\n // Mapping of tracked disabled SetTokens\n mapping(address => bool) disabledSets;\n\n // Array of tracked SetTokens\n address[] setTokens;\n\n // Array of tracked modules\n address[] modules;\n\n // Array of tracked factories\n address[] factories;\n\n // Array of tracked exchange wrappers\n address[] exchanges;\n\n // Array of tracked auction price libraries\n address[] priceLibraries;\n }\n\n /* ============ State Variables ============ */\n\n State public state;\n\n /* ============ Public Getters ============ */\n\n /**\n * Return uint8 representing the operational state of the protocol\n *\n * @return uint8 Uint8 representing the operational state of the protocol\n */\n function operationState()\n external\n view\n returns (uint8)\n {\n return state.operationState;\n }\n\n /**\n * Return address belonging to given exchangeId.\n *\n * @param _exchangeId ExchangeId number\n * @return address Address belonging to given exchangeId\n */\n function exchangeIds(\n uint8 _exchangeId\n )\n external\n view\n returns (address)\n {\n return state.exchangeIds[_exchangeId];\n }\n\n /**\n * Return transferProxy address.\n *\n * @return address transferProxy address\n */\n function transferProxy()\n external\n view\n returns (address)\n {\n return state.transferProxy;\n }\n\n /**\n * Return vault address\n *\n * @return address vault address\n */\n function vault()\n external\n view\n returns (address)\n {\n return state.vault;\n }\n\n /**\n * Return boolean indicating if address is valid factory.\n *\n * @param _factory Factory address\n * @return bool Boolean indicating if enabled factory\n */\n function validFactories(\n address _factory\n )\n external\n view\n returns (bool)\n {\n return state.validFactories[_factory];\n }\n\n /**\n * Return boolean indicating if address is valid module.\n *\n * @param _module Factory address\n * @return bool Boolean indicating if enabled factory\n */\n function validModules(\n address _module\n )\n external\n view\n returns (bool)\n {\n return state.validModules[_module];\n }\n\n /**\n * Return boolean indicating if address is valid Set.\n *\n * @param _set Set address\n * @return bool Boolean indicating if valid Set\n */\n function validSets(\n address _set\n )\n external\n view\n returns (bool)\n {\n return state.validSets[_set];\n }\n\n /**\n * Return boolean indicating if address is a disabled Set.\n *\n * @param _set Set address\n * @return bool Boolean indicating if is a disabled Set\n */\n function disabledSets(\n address _set\n )\n external\n view\n returns (bool)\n {\n return state.disabledSets[_set];\n }\n\n /**\n * Return boolean indicating if address is a valid Rebalancing Price Library.\n *\n * @param _priceLibrary Price library address\n * @return bool Boolean indicating if valid Price Library\n */\n function validPriceLibraries(\n address _priceLibrary\n )\n external\n view\n returns (bool)\n {\n return state.validPriceLibraries[_priceLibrary];\n }\n\n /**\n * Return array of all valid Set Tokens.\n *\n * @return address[] Array of valid Set Tokens\n */\n function setTokens()\n external\n view\n returns (address[] memory)\n {\n return state.setTokens;\n }\n\n /**\n * Return array of all valid Modules.\n *\n * @return address[] Array of valid modules\n */\n function modules()\n external\n view\n returns (address[] memory)\n {\n return state.modules;\n }\n\n /**\n * Return array of all valid factories.\n *\n * @return address[] Array of valid factories\n */\n function factories()\n external\n view\n returns (address[] memory)\n {\n return state.factories;\n }\n\n /**\n * Return array of all valid exchange wrappers.\n *\n * @return address[] Array of valid exchange wrappers\n */\n function exchanges()\n external\n view\n returns (address[] memory)\n {\n return state.exchanges;\n }\n\n /**\n * Return array of all valid price libraries.\n *\n * @return address[] Array of valid price libraries\n */\n function priceLibraries()\n external\n view\n returns (address[] memory)\n {\n return state.priceLibraries;\n }\n}\n"
},
{
"path": "contracts/core/lib/ExchangeHeaderLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { LibBytes } from \"../../external/0x/LibBytes.sol\";\n\n\n/**\n * @title ExchangeHeaderLibrary\n * @author Set Protocol\n *\n * This library contains functions and structs to assist with parsing exchange orders data\n */\nlibrary ExchangeHeaderLibrary {\n using LibBytes for bytes;\n using SafeMath for uint256;\n\n // ============ Structs ============\n\n struct ExchangeHeader {\n uint8 exchange;\n uint8 orderCount;\n uint256 orderDataBytesLength;\n }\n\n function EXCHANGE_HEADER_LENGTH()\n internal\n pure\n returns (uint256)\n {\n return uint256(96);\n }\n\n // ============ Internal Functions ============\n\n /**\n * Function to convert bytes into ExchangeHeader\n *\n * @param _orderData Bytes representing the order body information\n * @param _offset Bytes to offset orderData by\n * @return ExchangeHeader Struct containing data for a batch of exchange orders\n */\n function parseExchangeHeader(\n bytes memory _orderData,\n uint256 _offset\n )\n internal\n pure\n returns (ExchangeHeader memory)\n {\n ExchangeHeader memory header;\n\n uint256 headerDataStart = _orderData.contentAddress().add(_offset);\n\n assembly {\n mstore(header, mload(headerDataStart)) // exchange\n mstore(add(header, 32), mload(add(headerDataStart, 32))) // orderCount\n mstore(add(header, 64), mload(add(headerDataStart, 64))) // orderDataBytesLength\n }\n\n return header;\n }\n\n /**\n * Function to extract the exchange body from the order data\n *\n * @param _orderData Bytes representing the exchange order information\n * @param _scannedBytes Number representing the number of bytes already processed\n * @param _exchangeDataLength Length of the exchange data from the exchange data header\n * @return ExchangeBody Bytes representing the exchange body\n */\n function sliceBodyData(\n bytes memory _orderData,\n uint256 _scannedBytes,\n uint256 _exchangeDataLength\n )\n internal\n pure\n returns (bytes memory)\n {\n bytes memory bodyData = LibBytes.slice(\n _orderData,\n _scannedBytes.add(EXCHANGE_HEADER_LENGTH()),\n _scannedBytes.add(_exchangeDataLength)\n );\n\n return bodyData;\n }\n}\n"
},
{
"path": "contracts/core/lib/ExchangeWrapperLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IExchangeWrapper } from \"../interfaces/IExchangeWrapper.sol\";\nimport { ExchangeWrapperLibraryV2 } from \"./ExchangeWrapperLibraryV2.sol\";\nimport { LibBytes } from \"../../external/0x/LibBytes.sol\";\n\n\n/**\n * @title ExchangeWrapperLibrary\n * @author Set Protocol\n *\n * This library contains structs and functions to assist executing orders on third party exchanges\n */\nlibrary ExchangeWrapperLibrary {\n\n // ============ Structs ============\n\n /**\n * caller Original user initiating transaction\n * orderCount Expected number of orders to execute\n */\n struct ExchangeData {\n address caller;\n uint256 orderCount;\n }\n\n /**\n * receiveTokens A list of the acquired components from exchange wrapper\n * receiveTokenAmounts A list of the component quantities acquired\n */\n struct ExchangeResults {\n address[] receiveTokens;\n uint256[] receiveTokenAmounts;\n }\n\n /**\n * Checks if any send tokens leftover and transfers to caller\n * @param _sendTokens The addresses of send tokens\n * @param _caller The address of the original transaction caller\n */\n function returnLeftoverSendTokens(\n address[] memory _sendTokens,\n address _caller\n )\n internal\n {\n for (uint256 i = 0; i < _sendTokens.length; i++) {\n // Transfer any unused or remainder send token back to the caller\n uint256 remainderSendToken = ERC20Wrapper.balanceOf(_sendTokens[i], address(this));\n if (remainderSendToken > 0) {\n ERC20Wrapper.transfer(\n _sendTokens[i],\n _caller,\n remainderSendToken\n );\n }\n }\n }\n\n /**\n * Calls exchange to execute trades and deposits fills into Vault for issuanceOrder maker.\n *\n *\n * @param _core Address of Core\n * @param _exchangeData Standard exchange wrapper interface object containing exchange metadata\n * @param _exchangeWrapper Address of exchange wrapper being called\n * @param _bodyData Arbitrary bytes data for orders to be executed on exchange\n */\n function callExchange(\n address _core,\n ExchangeWrapperLibraryV2.ExchangeData memory _exchangeData,\n address _exchangeWrapper,\n bytes memory _bodyData\n )\n internal\n {\n // Call Exchange\n ExchangeWrapperLibraryV2.ExchangeResults memory exchangeResults = IExchangeWrapper(_exchangeWrapper).exchange(\n _exchangeData,\n _bodyData\n );\n\n // Transfer receiveToken tokens from wrapper to vault\n ICore(_core).batchDepositModule(\n _exchangeWrapper,\n _exchangeData.caller,\n exchangeResults.receiveTokens,\n exchangeResults.receiveTokenAmounts\n );\n }\n}\n"
},
{
"path": "contracts/core/lib/ExchangeWrapperLibraryV2.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\n\n/**\n * @title ExchangeWrapperLibrary\n * @author Set Protocol\n *\n * This library contains structs and functions to assist executing orders on third party exchanges\n *\n * CHANGELOG\n * - Removes functions that result in circular dependencies when trying to flatten.\n * - Functions using this library mainly use it for the structs\n */\nlibrary ExchangeWrapperLibraryV2 {\n\n // ============ Structs ============\n\n /**\n * caller Original user initiating transaction\n * orderCount Expected number of orders to execute\n */\n struct ExchangeData {\n address caller;\n uint256 orderCount;\n }\n\n /**\n * components A list of the acquired components from exchange wrapper\n * componentQuantities A list of the component quantities acquired\n */\n struct ExchangeResults {\n address[] receiveTokens;\n uint256[] receiveTokenAmounts;\n }\n}\n"
},
{
"path": "contracts/core/lib/Rebalance.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { IRebalancingSetToken } from \"../interfaces/IRebalancingSetToken.sol\";\n\n\n/**\n * @title Rebalance\n * @author Set Protocol\n *\n * Types and functions for Rebalance-related data.\n */\nlibrary Rebalance {\n\n struct TokenFlow {\n address[] addresses;\n uint256[] inflow;\n uint256[] outflow;\n }\n\n function composeTokenFlow(\n address[] memory _addresses,\n uint256[] memory _inflow,\n uint256[] memory _outflow\n )\n internal\n pure\n returns(TokenFlow memory)\n {\n return TokenFlow({addresses: _addresses, inflow: _inflow, outflow: _outflow });\n }\n\n function decomposeTokenFlow(TokenFlow memory _tokenFlow)\n internal\n pure\n returns (address[] memory, uint256[] memory, uint256[] memory)\n {\n return (_tokenFlow.addresses, _tokenFlow.inflow, _tokenFlow.outflow);\n }\n\n function decomposeTokenFlowToBidPrice(TokenFlow memory _tokenFlow)\n internal\n pure\n returns (uint256[] memory, uint256[] memory)\n {\n return (_tokenFlow.inflow, _tokenFlow.outflow);\n }\n\n /**\n * Get token flows array of addresses, inflows and outflows\n *\n * @param _rebalancingSetToken The rebalancing Set Token instance\n * @param _quantity The amount of currentSet to be rebalanced\n * @return combinedTokenArray Array of token addresses\n * @return inflowArray Array of amount of tokens inserted into system in bid\n * @return outflowArray Array of amount of tokens returned from system in bid\n */\n function getTokenFlows(\n IRebalancingSetToken _rebalancingSetToken,\n uint256 _quantity\n )\n internal\n view\n returns (address[] memory, uint256[] memory, uint256[] memory)\n {\n // Get token addresses\n address[] memory combinedTokenArray = _rebalancingSetToken.getCombinedTokenArray();\n\n // Get inflow and outflow arrays for the given bid quantity\n (\n uint256[] memory inflowArray,\n uint256[] memory outflowArray\n ) = _rebalancingSetToken.getBidPrice(_quantity);\n\n return (combinedTokenArray, inflowArray, outflowArray);\n }\n}\n"
},
{
"path": "contracts/core/lib/RebalancingLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title RebalancingLibrary\n * @author Set Protocol\n *\n * The RebalancingLibrary contains functions for facilitating the rebalancing process for\n * Rebalancing Set Tokens. Removes the old calculation functions\n *\n */\nlibrary RebalancingLibrary {\n\n /* ============ Enums ============ */\n\n enum State { Default, Proposal, Rebalance, Drawdown }\n\n /* ============ Structs ============ */\n\n struct AuctionPriceParameters {\n uint256 auctionStartTime;\n uint256 auctionTimeToPivot;\n uint256 auctionStartPrice;\n uint256 auctionPivotPrice;\n }\n\n struct BiddingParameters {\n uint256 minimumBid;\n uint256 remainingCurrentSets;\n uint256[] combinedCurrentUnits;\n uint256[] combinedNextSetUnits;\n address[] combinedTokenArray;\n }\n}\n"
},
{
"path": "contracts/core/lib/SetMath.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\n\n/**\n * @title SetMath\n * @author Set Protocol\n */\nlibrary SetMath {\n using SafeMath for uint256;\n\n \n /**\n * Converts SetToken quantity to component quantity\n */\n function setToComponent(\n uint256 _setQuantity,\n uint256 _componentUnit,\n uint256 _naturalUnit\n ) \n internal\n pure\n returns(uint256)\n {\n return _setQuantity.mul(_componentUnit).div(_naturalUnit);\n }\n\n /**\n * Converts component quantity to Set quantity\n */\n function componentToSet(\n uint256 _componentQuantity,\n uint256 _componentUnit,\n uint256 _naturalUnit\n ) \n internal\n pure\n returns(uint256)\n {\n return _componentQuantity.mul(_naturalUnit).div(_componentUnit);\n }\n}"
},
{
"path": "contracts/core/lib/SetTokenLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ICore} from \"../interfaces/ICore.sol\";\nimport { ISetToken} from \"../interfaces/ISetToken.sol\";\n\n\nlibrary SetTokenLibrary {\n using SafeMath for uint256;\n\n struct SetDetails {\n uint256 naturalUnit;\n address[] components;\n uint256[] units;\n }\n\n /**\n * Validates that passed in tokens are all components of the Set\n *\n * @param _set Address of the Set\n * @param _tokens List of tokens to check\n */\n function validateTokensAreComponents(\n address _set,\n address[] calldata _tokens\n )\n external\n view\n {\n for (uint256 i = 0; i < _tokens.length; i++) {\n // Make sure all tokens are members of the Set\n require(\n ISetToken(_set).tokenIsComponent(_tokens[i]),\n \"SetTokenLibrary.validateTokensAreComponents: Component must be a member of Set\"\n );\n\n }\n }\n\n /**\n * Validates that passed in quantity is a multiple of the natural unit of the Set.\n *\n * @param _set Address of the Set\n * @param _quantity Quantity to validate\n */\n function isMultipleOfSetNaturalUnit(\n address _set,\n uint256 _quantity\n )\n external\n view\n {\n require(\n _quantity.mod(ISetToken(_set).naturalUnit()) == 0,\n \"SetTokenLibrary.isMultipleOfSetNaturalUnit: Quantity is not a multiple of nat unit\"\n );\n }\n\n /**\n * Validates that passed in quantity is a multiple of the natural unit of the Set.\n *\n * @param _core Address of Core\n * @param _set Address of the Set\n */\n function requireValidSet(\n ICore _core,\n address _set\n )\n internal\n view\n {\n require(\n _core.validSets(_set),\n \"SetTokenLibrary: Must be an approved SetToken address\"\n );\n }\n\n /**\n * Retrieves the Set's natural unit, components, and units.\n *\n * @param _set Address of the Set\n * @return SetDetails Struct containing the natural unit, components, and units\n */\n function getSetDetails(\n address _set\n )\n internal\n view\n returns (SetDetails memory)\n {\n // Declare interface variables\n ISetToken setToken = ISetToken(_set);\n\n // Fetch set token properties\n uint256 naturalUnit = setToken.naturalUnit();\n address[] memory components = setToken.getComponents();\n uint256[] memory units = setToken.getUnits();\n\n return SetDetails({\n naturalUnit: naturalUnit,\n components: components,\n units: units\n });\n }\n}"
},
{
"path": "contracts/core/lib/auction-price-libraries/IAuctionPriceCurve.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { RebalancingLibrary } from \"../RebalancingLibrary.sol\";\n\n\n/**\n * @title IAuctionPriceCurve\n * @author Set Protocol\n *\n * The IAuctionPriceCurve interface provides a structured way to interact with any AuctionLibrary\n */\ninterface IAuctionPriceCurve {\n\n /*\n * Getter for priceDivisor variable on Auction Price Curve Library\n */\n function priceDivisor()\n external\n view\n returns (uint256);\n\n /*\n * Validate any auction parameters that have library-specific restrictions\n *\n * @param _auctionPriceParameters Struct containing relevant auction price parameters\n */\n function validateAuctionPriceParameters(\n RebalancingLibrary.AuctionPriceParameters calldata _auctionPriceParameters\n )\n external\n view;\n\n /*\n * Calculate the current priceRatio for an auction given defined price and time parameters\n *\n * @param _auctionPriceParameters Struct containing relevant auction price parameters\n * @return uint256 The auction price numerator\n * @return uint256 The auction price denominator\n */\n function getCurrentPrice(\n RebalancingLibrary.AuctionPriceParameters calldata _auctionPriceParameters\n )\n external\n view\n returns (uint256, uint256);\n}\n"
},
{
"path": "contracts/core/lib/auction-price-libraries/LinearAuctionPriceCurve.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { RebalancingLibrary } from \"../RebalancingLibrary.sol\";\n\n\n/**\n * @title LinearAuctionPriceCurve\n * @author Set Protocol\n *\n * Contract used in rebalancing auctions to calculate price based off of a linear curve\n */\ncontract LinearAuctionPriceCurve {\n using SafeMath for uint256;\n\n uint256 constant public MIN_PIVOT_PRICE_DIVISOR = 5;\n uint256 constant public MAX_PIVOT_PRICE_NUMERATOR = 5;\n uint256 constant public MAX_30_SECOND_PERIODS = 1000;\n uint256 constant public THIRTY_SECONDS = 30;\n\n uint256 public priceDivisor;\n bool public usesStartPrice;\n\n /*\n * Declare price denominator (or precision) of price curve\n *\n * @param _priceDivisor The priceDivisor you want this library to always return\n * @param _usesStartPrice Boolean indicating if provided auctionStartPrice is used (true) or\n * auction starts at 0 (false)\n */\n constructor(\n uint256 _priceDivisor,\n bool _usesStartPrice\n )\n public\n {\n // Set price to be returned by library\n priceDivisor = _priceDivisor;\n usesStartPrice = _usesStartPrice;\n }\n\n /*\n * Validate any auction parameters that have library-specific restrictions\n *\n * @param _auctionPriceParameters Struct containing relevant auction price parameters\n */\n function validateAuctionPriceParameters(\n RebalancingLibrary.AuctionPriceParameters memory _auctionPriceParameters\n )\n public\n view\n {\n // Require that auction pivot price is greater than auction start price\n require(\n _auctionPriceParameters.auctionPivotPrice > _auctionPriceParameters.auctionStartPrice,\n \"LinearAuctionPriceCurve.validateAuctionPriceParameters: Start price greater than pivot price\"\n );\n\n // Require pivot price to be greater than 0.5 * price denominator\n // Equivalent to oldSet/newSet = 0.5\n require(\n _auctionPriceParameters.auctionPivotPrice > priceDivisor.div(MIN_PIVOT_PRICE_DIVISOR),\n \"LinearAuctionPriceCurve.validateAuctionPriceParameters: Pivot price too low\"\n );\n // Require pivot price to be less than 5 * price denominator\n // Equivalent to oldSet/newSet = 5\n require(\n _auctionPriceParameters.auctionPivotPrice < priceDivisor.mul(MAX_PIVOT_PRICE_NUMERATOR),\n \"LinearAuctionPriceCurve.validateAuctionPriceParameters: Pivot price too high\"\n );\n }\n\n /*\n * Calculate the current priceRatio for an auction given defined price and time parameters\n *\n * @param _auctionPriceParameters Struct containing relevant auction price parameters\n * @return uint256 The auction price numerator\n * @return uint256 The auction price denominator\n */\n function getCurrentPrice(\n RebalancingLibrary.AuctionPriceParameters memory _auctionPriceParameters\n )\n public\n view\n returns (uint256, uint256)\n {\n // Calculate how much time has elapsed since start of auction\n uint256 elapsed = block.timestamp.sub(_auctionPriceParameters.auctionStartTime);\n\n // Initialize numerator and denominator\n uint256 priceNumerator = _auctionPriceParameters.auctionPivotPrice;\n uint256 currentPriceDivisor = priceDivisor;\n\n // Determine the auctionStartPrice based on if it should be self-defined\n uint256 auctionStartPrice = 0;\n if (usesStartPrice) {\n auctionStartPrice = _auctionPriceParameters.auctionStartPrice;\n }\n\n /*\n * This price curve can be broken down into three stages, 1) set up to allow a portion where managers\n * have control over the cadence of the auction, and then two more stages that are used to enforce finality\n * to the auction. The auction price, p(x), is defined by:\n *\n * p(x) = (priceNumerator/priceDivisor\n *\n * In each stage either the priceNumerator or priceDivisor is manipulated to change p(x).The curve shape\n * in each stage is defined below.\n *\n * 1) Managers have the greatest control over stage 1. Here they define a linear curve that starts at zero\n * and terminates at the passed pivot price. The length of time it takes for the auction to reach the pivot\n * price is defined by the manager too, thus resulting in the following equation for the slope of the line:\n *\n * PriceNumerator(x) = auctionStartPrice + (auctionPivotPrice-auctionStartPrice)*(x/auctionTimeToPivot),\n * where x is amount of time from auction start\n *\n * 2) Stage 2 the protocol takes over to attempt to hasten/guarantee finality, this unfortunately decreases\n * the granularity of the auction price changes. In this stage the PriceNumerator remains fixed at the\n * auctionPivotPrice. However, the priceDivisor decays at a rate equivalent to 0.1% of the ORIGINAL\n * priceDivisor every 30 secs. This leads to the following function relative to time:\n *\n * PriceDenominator(x) = priceDivisor-(0.01*priceDivisor*((x-auctionTimeToPivot)/30)), where x is amount\n * of time from auction start.\n *\n * Since we are decaying the denominator the price curve takes on the shape of e^x. Because of the limitations\n * of integer math the denominator can only be decayed to 1. Hence in order to maintain simplicity in calculations\n * there is a third segment defined below.\n *\n * 3) The third segment is a simple linear calculation that changes the priceNumerator at the rate of the pivot\n * price every 30 seconds and fixes the priceDivisor at 1:\n *\n * PriceNumerator(x) = auctionPivotPrice + auctionPivotPrice*(x-auctionTimeToPivot-30000), where x is amount of\n * time from auction start and 30000 represents the amount of time spent in Stage 2\n */\n\n // If time hasn't passed to pivot use the user-defined curve\n if (elapsed <= _auctionPriceParameters.auctionTimeToPivot) {\n // Calculate the priceNumerator as a linear function of time between _auctionStartPrice and\n // _auctionPivotPrice\n uint256 linearPriceDifference = _auctionPriceParameters.auctionPivotPrice.sub(auctionStartPrice);\n priceNumerator = auctionStartPrice.add(\n elapsed.mul(linearPriceDifference).div(_auctionPriceParameters.auctionTimeToPivot)\n );\n } else {\n // Calculate how many 30 second increments have passed since pivot was reached\n uint256 thirtySecondPeriods = elapsed\n .sub(_auctionPriceParameters.auctionTimeToPivot)\n .div(THIRTY_SECONDS);\n\n // Because after 1000 thirtySecondPeriods the priceDivisor would be 0 (causes revert)\n if (thirtySecondPeriods < MAX_30_SECOND_PERIODS) {\n // Calculate new denominator where the denominator decays at a rate of 0.1% of the ORIGINAL\n // priceDivisor per time increment (hence divide by 1000)\n currentPriceDivisor = priceDivisor\n .sub(thirtySecondPeriods\n .mul(priceDivisor)\n .div(MAX_30_SECOND_PERIODS)\n );\n } else {\n // Once denominator has fully decayed, fix it at 1\n currentPriceDivisor = 1;\n\n // Now priceNumerator just changes linearly, but with slope equal to the pivot price\n priceNumerator = _auctionPriceParameters.auctionPivotPrice.add(\n _auctionPriceParameters.auctionPivotPrice.mul(thirtySecondPeriods.sub(MAX_30_SECOND_PERIODS))\n );\n }\n }\n\n return (priceNumerator, currentPriceDivisor);\n }\n}\n"
},
{
"path": "contracts/core/liquidators/LinearAuctionLiquidator.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { ILiquidator } from \"../interfaces/ILiquidator.sol\";\nimport { IOracleWhiteList } from \"../interfaces/IOracleWhiteList.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { Auction } from \"./impl/Auction.sol\";\nimport { LinearAuction } from \"./impl/LinearAuction.sol\";\nimport { Rebalance } from \"../lib/Rebalance.sol\";\nimport { RebalancingLibrary } from \"../lib/RebalancingLibrary.sol\";\nimport { TwoAssetPriceBoundedLinearAuction } from \"./impl/TwoAssetPriceBoundedLinearAuction.sol\";\n\n\n/**\n * @title LinearAuctionLiquidator\n * @author Set Protocol\n *\n * Contract that holds all the state and functionality required for setting up, returning prices, and tearing\n * down linear auction rebalances for RebalancingSetTokens.\n */\ncontract LinearAuctionLiquidator is TwoAssetPriceBoundedLinearAuction, ILiquidator {\n using SafeMath for uint256;\n\n ICore public core;\n string public name;\n mapping(address => LinearAuction.State) public auctions;\n\n /* ============ Modifier ============ */\n modifier isValidSet() {\n requireValidSet(msg.sender);\n _;\n }\n\n /**\n * LinearAuctionLiquidator constructor\n *\n * @param _core Core instance\n * @param _oracleWhiteList Oracle WhiteList instance\n * @param _auctionPeriod Length of auction\n * @param _rangeStart Percentage above FairValue to begin auction at\n * @param _rangeEnd Percentage below FairValue to end auction at \n * @param _name Descriptive name of Liquidator\n */\n constructor(\n ICore _core,\n IOracleWhiteList _oracleWhiteList,\n uint256 _auctionPeriod,\n uint256 _rangeStart,\n uint256 _rangeEnd,\n string memory _name\n )\n public\n TwoAssetPriceBoundedLinearAuction(\n _oracleWhiteList,\n _auctionPeriod,\n _rangeStart,\n _rangeEnd\n )\n {\n core = _core;\n name = _name;\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Initiates a linear auction. Can only be called by a SetToken.\n *\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @param _startingCurrentSetQuantity The currentSet quantity to rebalance\n * @param _liquidatorData Bytecode formatted data with liquidator-specific arguments\n */\n function startRebalance(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n bytes calldata _liquidatorData\n )\n external\n isValidSet\n {\n _liquidatorData; // Pass linting\n\n TwoAssetPriceBoundedLinearAuction.validateTwoAssetPriceBoundedAuction(\n _currentSet,\n _nextSet\n );\n\n LinearAuction.initializeLinearAuction(\n linearAuction(msg.sender),\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity\n );\n }\n\n /**\n * Reduces the remainingCurrentSet quantity and retrieves the current\n * bid price.\n * Can only be called by a SetToken during an active auction\n *\n * @param _quantity The currentSetQuantity to rebalance\n * @return TokenFlow Struct with array, inflow, and outflow data \n */\n function placeBid(\n uint256 _quantity\n )\n external\n isValidSet\n returns (Rebalance.TokenFlow memory)\n {\n Auction.validateBidQuantity(auction(msg.sender), _quantity);\n\n Auction.reduceRemainingCurrentSets(auction(msg.sender), _quantity);\n\n return getBidPrice(msg.sender, _quantity);\n }\n\n /**\n * Retrieves the current auction price for the particular Set\n *\n * @param _set Address of the SetToken\n * @param _quantity The currentSetQuantity to rebalance\n * @return TokenFlow Struct with array, inflow, and outflow data\n */\n function getBidPrice(\n address _set,\n uint256 _quantity\n )\n public\n view\n returns (Rebalance.TokenFlow memory)\n { \n return LinearAuction.getTokenFlow(linearAuction(_set), _quantity);\n }\n\n /**\n * Validates auction completion and clears auction state.\n */\n function settleRebalance() external isValidSet {\n\n Auction.validateAuctionCompletion(auction(msg.sender));\n\n clearAuctionState(msg.sender);\n }\n\n /**\n * Clears auction state.\n */\n function endFailedRebalance() external isValidSet {\n\n clearAuctionState(msg.sender);\n }\n\n /* ============ Getters Functions ============ */\n\n function hasRebalanceFailed(address _set) external view returns (bool) {\n return LinearAuction.hasAuctionFailed(linearAuction(_set));\n }\n\n function minimumBid(address _set) external view returns (uint256) {\n return auction(_set).minimumBid;\n }\n\n function remainingCurrentSets(address _set) external view returns (uint256) {\n return auction(_set).remainingCurrentSets;\n }\n\n function startingCurrentSets(address _set) external view returns (uint256) {\n return auction(_set).startingCurrentSets;\n }\n\n function getCombinedTokenArray(address _set) external view returns (address[] memory) {\n return auction(_set).combinedTokenArray;\n }\n\n function getCombinedCurrentSetUnits(address _set) external view returns (uint256[] memory) {\n return auction(_set).combinedCurrentSetUnits;\n }\n\n function getCombinedNextSetUnits(address _set) external view returns (uint256[] memory) {\n return auction(_set).combinedNextSetUnits;\n }\n\n function auctionPriceParameters(address _set)\n external\n view\n returns (RebalancingLibrary.AuctionPriceParameters memory)\n {\n return RebalancingLibrary.AuctionPriceParameters({\n auctionStartTime: auction(_set).startTime,\n auctionTimeToPivot: auctionPeriod,\n auctionStartPrice: linearAuction(_set).startPrice,\n auctionPivotPrice: linearAuction(_set).endPrice\n });\n }\n\n /* ============ Private Functions ============ */\n\n function clearAuctionState(address _set) private {\n delete auctions[_set];\n }\n\n function auction(address _set) private view returns(Auction.Setup storage) {\n return linearAuction(_set).auction;\n }\n\n function linearAuction(address _set) private view returns(LinearAuction.State storage) {\n return auctions[_set];\n }\n\n function requireValidSet(address _set) private view {\n require(\n core.validSets(_set),\n \"LinearAuctionLiquidator: Invalid or disabled proposed SetToken address\"\n ); \n }\n}"
},
{
"path": "contracts/core/liquidators/TWAPLiquidator.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Ownable } from \"openzeppelin-solidity/contracts/ownership/Ownable.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { BoundsLibrary } from \"set-protocol-contract-utils/contracts/lib/BoundsLibrary.sol\";\n\nimport { Auction } from \"./impl/Auction.sol\";\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { ILiquidator } from \"../interfaces/ILiquidator.sol\";\nimport { IOracleWhiteList } from \"../interfaces/IOracleWhiteList.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { LinearAuction } from \"./impl/LinearAuction.sol\";\nimport { Rebalance } from \"../lib/Rebalance.sol\";\nimport { RebalancingLibrary } from \"../lib/RebalancingLibrary.sol\";\nimport { TWAPAuction } from \"./twap-impl/TWAPAuction.sol\";\nimport { TWAPAuctionGetters } from \"./twap-impl/TWAPAuctionGetters.sol\";\nimport { TwoAssetPriceBoundedLinearAuction } from \"./impl/TwoAssetPriceBoundedLinearAuction.sol\";\n\n\n/**\n * @title TWAPLiquidator\n * @author Set Protocol\n *\n * Contract that holds all the state and functionality required for setting up, returning prices, and tearing\n * down TWAP rebalances for RebalancingSetTokens.\n */\ncontract TWAPLiquidator is\n ILiquidator,\n TWAPAuction,\n TWAPAuctionGetters,\n Ownable\n{\n using SafeMath for uint256;\n\n /* ============ Events ============ */\n event ChunkAuctionIterated(\n address indexed rebalancingSetToken,\n uint256 orderRemaining,\n uint256 startingCurrentSets\n );\n\n event ChunkSizeBoundUpdated(\n address assetOne,\n address assetTwo,\n uint256 lowerBound,\n uint256 upperBound\n );\n\n ICore public core;\n string public name;\n // Maps RebalancingSetToken to it's auction state\n mapping(address => TWAPAuction.TWAPState) public auctions;\n\n /* ============ Modifier ============ */\n modifier onlyValidSet() {\n require(\n core.validSets(msg.sender),\n \"TWAPLiquidator: Invalid or disabled proposed SetToken address\"\n );\n _;\n }\n\n /**\n * TWAPLiquidator constructor\n *\n * @param _core Core instance\n * @param _oracleWhiteList Oracle WhiteList instance\n * @param _auctionPeriod Length of auction in seconds\n * @param _rangeStart Percentage above FairValue to begin auction at in 18 decimal value\n * @param _rangeEnd Percentage below FairValue to end auction at in 18 decimal value\n * @param _assetPairVolumeBounds List of asset pair USD-denominated chunk auction size bounds\n * @param _name Descriptive name of Liquidator\n */\n constructor(\n ICore _core,\n IOracleWhiteList _oracleWhiteList,\n uint256 _auctionPeriod,\n uint256 _rangeStart,\n uint256 _rangeEnd,\n TWAPAuction.AssetPairVolumeBounds[] memory _assetPairVolumeBounds,\n string memory _name\n )\n public\n TWAPAuction(\n _oracleWhiteList,\n _auctionPeriod,\n _rangeStart,\n _rangeEnd,\n _assetPairVolumeBounds\n )\n {\n core = _core;\n name = _name;\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Initiates a TWAP auction. Can only be called by a SetToken.\n *\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @param _startingCurrentSetQuantity The currentSet quantity to rebalance\n * @param _liquidatorData Bytecode formatted data with TWAPLiquidator-specific arguments\n */\n function startRebalance(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n bytes calldata _liquidatorData\n )\n external\n onlyValidSet\n {\n // Validates only 2 components are involved and are supported by oracles\n TwoAssetPriceBoundedLinearAuction.validateTwoAssetPriceBoundedAuction(\n _currentSet,\n _nextSet\n );\n\n // Retrieve the chunk auction size and auction period from liquidator data.\n (\n uint256 chunkAuctionValue,\n uint256 chunkAuctionPeriod\n ) = TWAPAuction.parseLiquidatorData(_liquidatorData);\n\n // Chunk size must be within bounds and total rebalance length must be below fail auction time\n TWAPAuction.validateLiquidatorData(\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity,\n chunkAuctionValue,\n chunkAuctionPeriod\n );\n\n // Initializes TWAP Auction and commits to TWAP state\n TWAPAuction.initializeTWAPAuction(\n auctions[msg.sender],\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity,\n chunkAuctionValue,\n chunkAuctionPeriod\n );\n }\n\n /**\n * Reduces the remainingCurrentSet quantity and retrieves the current\n * bid price for the chunk auction. If this auction completes the chunkAuction,\n * the lastChunkAuction parameter is updated.\n * Can only be called by a SetToken during an active auction\n *\n * @param _quantity The currentSetQuantity to rebalance\n * @return TokenFlow Struct with array, inflow, and outflow data\n */\n function placeBid(\n uint256 _quantity\n )\n external\n onlyValidSet\n returns (Rebalance.TokenFlow memory)\n {\n Auction.validateBidQuantity(auction(msg.sender), _quantity);\n\n Auction.reduceRemainingCurrentSets(auction(msg.sender), _quantity);\n\n // If the auction is complete, update the chunk auction end time to the present timestamp\n if (!hasBiddableQuantity(auction(msg.sender))) {\n twapAuction(msg.sender).lastChunkAuctionEnd = block.timestamp;\n }\n\n return getBidPrice(msg.sender, _quantity);\n }\n\n /**\n * Initiates the next chunk auction. Callable by anybody.\n *\n * @param _set Address of the RebalancingSetToken\n */\n function iterateChunkAuction(address _set) external {\n TWAPAuction.TWAPState storage twapAuction = twapAuction(_set);\n validateNextChunkAuction(twapAuction);\n\n auctionNextChunk(twapAuction);\n\n emit ChunkAuctionIterated(\n _set,\n twapAuction.orderRemaining,\n twapAuction.chunkAuction.auction.startingCurrentSets\n );\n }\n\n /**\n * Validates auction completion and clears auction state. Callable only by a SetToken.\n */\n function settleRebalance() external onlyValidSet {\n require(\n !(TWAPAuction.isRebalanceActive(twapAuction(msg.sender))),\n \"TWAPLiquidator: Rebalance must be complete\"\n );\n\n clearAuctionState(msg.sender);\n }\n\n /**\n * Clears auction state.\n */\n function endFailedRebalance() external onlyValidSet {\n clearAuctionState(msg.sender);\n }\n\n /**\n * Retrieves the current chunk auction price for the particular Set\n *\n * @param _set Address of the SetToken\n * @param _quantity The chunk auction's currentSetQuantity to rebalance\n * @return TokenFlow Struct with array, inflow, and outflow data\n */\n function getBidPrice(\n address _set,\n uint256 _quantity\n )\n public\n view\n returns (Rebalance.TokenFlow memory)\n {\n return LinearAuction.getTokenFlow(chunkAuction(_set), _quantity);\n }\n\n /**\n * Admin function to modify chunk sizes for an asset pair.\n *\n * @param _assetOne Address of the first asset\n * @param _assetTwo Address of the second asset\n * @param _assetPairVolumeBounds Asset pair USD-denominated chunk auction size bounds\n */\n function setChunkSizeBounds(\n address _assetOne,\n address _assetTwo,\n BoundsLibrary.Bounds memory _assetPairVolumeBounds\n )\n public\n onlyOwner\n {\n require(\n BoundsLibrary.isValid(_assetPairVolumeBounds),\n \"TWAPLiquidator: Bounds invalid\"\n );\n\n chunkSizeWhiteList[_assetOne][_assetTwo] = _assetPairVolumeBounds;\n chunkSizeWhiteList[_assetTwo][_assetOne] = _assetPairVolumeBounds;\n\n emit ChunkSizeBoundUpdated(\n _assetOne,\n _assetTwo,\n _assetPairVolumeBounds.lower,\n _assetPairVolumeBounds.upper\n );\n }\n\n /* ============ Getters Functions ============ */\n\n function hasRebalanceFailed(address _set) external view returns (bool) {\n return LinearAuction.hasAuctionFailed(chunkAuction(_set));\n }\n\n function auctionPriceParameters(address _set)\n external\n view\n returns (RebalancingLibrary.AuctionPriceParameters memory)\n {\n return RebalancingLibrary.AuctionPriceParameters({\n auctionStartTime: auction(_set).startTime,\n auctionTimeToPivot: auctionPeriod,\n auctionStartPrice: chunkAuction(_set).startPrice,\n auctionPivotPrice: chunkAuction(_set).endPrice\n });\n }\n\n function getTotalSetsRemaining(address _set) external view returns (uint256) {\n return TWAPAuction.calculateTotalSetsRemaining(twapAuction(_set));\n }\n\n /**\n * Converts the chunkSize and chunkAuctionPeriod into liquidator data.\n *\n * _chunkSizeValue Currency value of rebalance volume in each chunk (18 decimal)\n * _chunkAuctionPeriod Time between chunk auctions\n * @return bytes Bytes encoded liquidator data\n */\n function getLiquidatorData(\n uint256 _chunkSize,\n uint256 _chunkAuctionPeriod\n )\n external\n view\n returns(bytes memory)\n {\n return abi.encode(_chunkSize, _chunkAuctionPeriod);\n }\n\n /* ============ Private Functions ============ */\n\n function clearAuctionState(address _set) internal {\n delete auctions[_set];\n }\n\n function twapAuction(address _set) internal view returns(TWAPAuction.TWAPState storage) {\n return auctions[_set];\n }\n\n function chunkAuction(address _set) internal view returns(LinearAuction.State storage) {\n return twapAuction(_set).chunkAuction;\n }\n\n function auction(address _set) internal view returns(Auction.Setup storage) {\n return chunkAuction(_set).auction;\n }\n}"
},
{
"path": "contracts/core/liquidators/impl/Auction.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\nimport { IOracle } from \"set-protocol-oracles/contracts/meta-oracles/interfaces/IOracle.sol\";\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { Rebalance } from \"../../lib/Rebalance.sol\";\nimport { SetMath } from \"../../lib/SetMath.sol\";\n\n\n/**\n * @title Auction\n * @author Set Protocol\n *\n * Contract containing utility functions for liquidators that use auctions processes. Contains\n * helper functions to value collateral SetTokens and determine parameters used in bidding\n * processes. Meant to be inherited.\n */\ncontract Auction {\n using SafeMath for uint256;\n using AddressArrayUtils for address[];\n\n /* ============ Structs ============ */\n struct Setup {\n uint256 maxNaturalUnit;\n uint256 minimumBid;\n uint256 startTime;\n uint256 startingCurrentSets;\n uint256 remainingCurrentSets;\n address[] combinedTokenArray;\n uint256[] combinedCurrentSetUnits;\n uint256[] combinedNextSetUnits;\n }\n\n /* ============ Structs ============ */\n uint256 constant private CURVE_DENOMINATOR = 10 ** 18;\n\n /* ============ Auction Struct Methods ============ */\n\n /*\n * Sets the Auction Setup struct variables.\n *\n * @param _auction Auction Setup object\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @param _startingCurrentSetQuantity Quantity of currentSet to rebalance\n */\n function initializeAuction(\n Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity\n )\n internal\n {\n _auction.maxNaturalUnit = Math.max(\n _currentSet.naturalUnit(),\n _nextSet.naturalUnit()\n );\n\n _auction.startingCurrentSets = _startingCurrentSetQuantity;\n _auction.remainingCurrentSets = _startingCurrentSetQuantity;\n _auction.startTime = block.timestamp;\n _auction.combinedTokenArray = getCombinedTokenArray(_currentSet, _nextSet);\n _auction.combinedCurrentSetUnits = calculateCombinedUnitArray(_auction, _currentSet);\n _auction.combinedNextSetUnits = calculateCombinedUnitArray(_auction, _nextSet);\n }\n\n function reduceRemainingCurrentSets(Setup storage _auction, uint256 _quantity) internal {\n _auction.remainingCurrentSets = _auction.remainingCurrentSets.sub(_quantity);\n }\n\n /*\n * Validate bid is a multiple of minimum bid and that amount is less than remaining.\n */\n function validateBidQuantity(Setup storage _auction, uint256 _quantity) internal view {\n require(\n _quantity.mod(_auction.minimumBid) == 0,\n \"Auction.validateBidQuantity: Must bid multiple of minimum bid\"\n );\n\n require(\n _quantity <= _auction.remainingCurrentSets,\n \"Auction.validateBidQuantity: Bid exceeds remaining current sets\"\n );\n }\n\n /*\n * Asserts whether the auction has been completed, which is when all currentSets have been\n * rebalanced.\n */\n function validateAuctionCompletion(Setup storage _auction) internal view {\n require(\n !hasBiddableQuantity(_auction),\n \"Auction.settleRebalance: Rebalance not completed\"\n );\n }\n\n /**\n * Returns whether the remainingSets is still a quantity equal or greater than the minimum bid\n */\n function hasBiddableQuantity(Setup storage _auction) internal view returns(bool) {\n return _auction.remainingCurrentSets >= _auction.minimumBid;\n }\n\n /**\n * Returns whether the auction is active\n */\n function isAuctionActive(Setup storage _auction) internal view returns(bool) {\n return _auction.startTime > 0;\n }\n\n /*\n * Calculates TokenFlows\n *\n * @param _auction Auction Setup object\n * @param _quantity Amount of currentSets bidder is seeking to rebalance\n * @param _price Value representing the auction numeartor\n */\n function calculateTokenFlow(\n Setup storage _auction,\n uint256 _quantity,\n uint256 _price\n )\n internal\n view\n returns (Rebalance.TokenFlow memory)\n {\n // Normalized quantity amount\n uint256 unitsMultiplier = _quantity.div(_auction.maxNaturalUnit);\n\n address[] memory memCombinedTokenArray = _auction.combinedTokenArray;\n\n uint256 combinedTokenCount = memCombinedTokenArray.length;\n uint256[] memory inflowUnitArray = new uint256[](combinedTokenCount);\n uint256[] memory outflowUnitArray = new uint256[](combinedTokenCount);\n\n // Cycle through each token in combinedTokenArray, calculate inflow/outflow and store\n // result in array\n for (uint256 i = 0; i < combinedTokenCount; i++) {\n (\n inflowUnitArray[i],\n outflowUnitArray[i]\n ) = calculateInflowOutflow(\n _auction.combinedCurrentSetUnits[i],\n _auction.combinedNextSetUnits[i],\n unitsMultiplier,\n _price\n );\n }\n\n return Rebalance.composeTokenFlow(memCombinedTokenArray, inflowUnitArray, outflowUnitArray);\n }\n\n /**\n * Computes the union of the currentSet and nextSet components\n *\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @return Aggregated components array\n */\n function getCombinedTokenArray(\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns(address[] memory)\n {\n address[] memory currentSetComponents = _currentSet.getComponents();\n address[] memory nextSetComponents = _nextSet.getComponents();\n return currentSetComponents.union(nextSetComponents);\n }\n\n /*\n * Calculates token inflow/outflow for single component in combinedTokenArray\n *\n * @param _currentUnit Amount of token i in currentSet per minimum bid amount\n * @param _nextSetUnit Amount of token i in nextSet per minimum bid amount\n * @param _unitsMultiplier Bid amount normalized to number of minimum bid amounts\n * @param _price Auction price numerator with 10 ** 18 as denominator\n * @return inflowUnit Amount of token i transferred into the system\n * @return outflowUnit Amount of token i transferred to the bidder\n */\n function calculateInflowOutflow(\n uint256 _currentUnit,\n uint256 _nextSetUnit,\n uint256 _unitsMultiplier,\n uint256 _price\n )\n internal\n pure\n returns (uint256, uint256)\n {\n /*\n * Below is a mathematically simplified formula for calculating token inflows and\n * outflows, the following is it's derivation:\n * token_flow = (bidQuantity/price)*(nextUnit - price*currentUnit)\n *\n * Where,\n * 1) price = (priceNumerator/priceDivisor),\n * 2) nextUnit and currentUnit are the amount of component i needed for a\n * standardAmount of sets to be rebalanced where one standardAmount =\n * max(natural unit nextSet, natural unit currentSet), and\n * 3) bidQuantity is a normalized amount in terms of the standardAmount used\n * to calculate nextUnit and currentUnit. This is represented by the unitsMultiplier\n * variable.\n *\n * Given these definitions we can derive the below formula as follows:\n * token_flow = (unitsMultiplier/(priceNumerator/priceDivisor))*\n * (nextUnit - (priceNumerator/priceDivisor)*currentUnit)\n *\n * We can then multiply this equation by (priceDivisor/priceDivisor)\n * which simplifies the above equation to:\n *\n * (unitsMultiplier/priceNumerator)* (nextUnit*priceDivisor - currentUnit*priceNumerator)\n *\n * This is the equation seen below, but since unsigned integers are used we must check to see if\n * nextUnit*priceDivisor > currentUnit*priceNumerator, otherwise those two terms must be\n * flipped in the equation.\n */\n uint256 inflowUnit;\n uint256 outflowUnit;\n\n // Use if statement to check if token inflow or outflow\n if (_nextSetUnit.mul(CURVE_DENOMINATOR) > _currentUnit.mul(_price)) {\n // Calculate inflow amount\n inflowUnit = _unitsMultiplier.mul(\n _nextSetUnit.mul(CURVE_DENOMINATOR).sub(_currentUnit.mul(_price))\n ).div(_price);\n\n // Set outflow amount to 0 for component i, since tokens need to be injected in rebalance\n outflowUnit = 0;\n } else {\n // Calculate outflow amount\n outflowUnit = _unitsMultiplier.mul(\n _currentUnit.mul(_price).sub(_nextSetUnit.mul(CURVE_DENOMINATOR))\n ).div(_price);\n\n // Set inflow amount to 0 for component i, since tokens need to be returned in rebalance\n inflowUnit = 0;\n }\n\n return (inflowUnit, outflowUnit);\n }\n\n /* ============ Token Array Creation Helpers ============ */\n\n /**\n * Create uint256 arrays that represents all components in currentSet and nextSet.\n * Calcualate unit difference between both sets relative to the largest natural\n * unit of the two sets.\n *\n * @param _auction Auction Setup object\n * @param _set The Set to generate units for\n * @return combinedUnits \n */\n function calculateCombinedUnitArray(\n Setup storage _auction,\n ISetToken _set\n )\n internal\n view\n returns (uint256[] memory)\n {\n address[] memory combinedTokenArray = _auction.combinedTokenArray;\n uint256[] memory combinedUnits = new uint256[](combinedTokenArray.length);\n for (uint256 i = 0; i < combinedTokenArray.length; i++) {\n combinedUnits[i] = calculateCombinedUnit(\n _set,\n _auction.maxNaturalUnit,\n combinedTokenArray[i]\n );\n }\n\n return combinedUnits;\n }\n\n /**\n * Calculations the unit amount of Token to include in the the combined Set units.\n *\n * @param _setToken Information on the SetToken\n * @param _maxNaturalUnit Max natural unit of two sets in rebalance\n * @param _component Current component in iteration\n * @return Unit inflow/outflow\n */\n function calculateCombinedUnit(\n ISetToken _setToken,\n uint256 _maxNaturalUnit,\n address _component\n )\n private\n view\n returns (uint256)\n {\n // Check if component in arrays and get index if it is\n (\n uint256 indexCurrent, \n bool isComponent\n ) = _setToken.getComponents().indexOf(_component);\n\n // Compute unit amounts of token in Set\n if (isComponent) {\n return calculateTransferValue(\n _setToken.getUnits()[indexCurrent],\n _setToken.naturalUnit(),\n _maxNaturalUnit\n );\n }\n\n return 0;\n }\n\n /**\n * Function to calculate the transfer value of a component given a standardized bid amount\n * (minimumBid/priceDivisor)\n *\n * @param _unit Units of the component token\n * @param _naturalUnit Natural unit of the Set token\n * @param _maxNaturalUnit Max natural unit of two sets in rebalance\n * @return uint256 Amount of tokens per standard bid amount (minimumBid/priceDivisor)\n */\n function calculateTransferValue(\n uint256 _unit,\n uint256 _naturalUnit,\n uint256 _maxNaturalUnit\n )\n private\n pure\n returns (uint256)\n {\n return SetMath.setToComponent(_maxNaturalUnit, _unit, _naturalUnit);\n }\n}"
},
{
"path": "contracts/core/liquidators/impl/AuctionGetters.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Auction } from \"./Auction.sol\";\n\n\n/**\n * @title AuctionGetters\n * @author Set Protocol\n *\n * Contract containing getters for receiving data from Auction.Setup struct. The auction() getter is implemented in the\n * inheriting contract.\n */\ncontract AuctionGetters {\n\n function minimumBid(address _set) external view returns (uint256) {\n return auction(_set).minimumBid;\n }\n\n function remainingCurrentSets(address _set) external view returns (uint256) {\n return auction(_set).remainingCurrentSets;\n }\n\n function startingCurrentSets(address _set) external view returns (uint256) {\n return auction(_set).startingCurrentSets;\n }\n\n function getCombinedTokenArray(address _set) external view returns (address[] memory) {\n return auction(_set).combinedTokenArray;\n }\n\n function getCombinedCurrentSetUnits(address _set) external view returns (uint256[] memory) {\n return auction(_set).combinedCurrentSetUnits;\n }\n\n function getCombinedNextSetUnits(address _set) external view returns (uint256[] memory) {\n return auction(_set).combinedNextSetUnits;\n }\n\n function auction(address _set) internal view returns(Auction.Setup storage);\n}"
},
{
"path": "contracts/core/liquidators/impl/LinearAuction.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { Auction } from \"./Auction.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { Rebalance } from \"../../lib/Rebalance.sol\";\n\n\n/**\n * @title LinearAuction\n * @author Set Protocol\n *\n * Library containing utility functions for computing auction Price for a linear price auction.\n */\ncontract LinearAuction is Auction {\n using SafeMath for uint256;\n\n /* ============ Structs ============ */\n struct State {\n Auction.Setup auction;\n uint256 endTime;\n uint256 startPrice;\n uint256 endPrice;\n }\n\n /* ============ State Variables ============ */\n uint256 public auctionPeriod; // Length in seconds of auction\n\n /**\n * LinearAuction constructor\n *\n * @param _auctionPeriod Length of auction\n */\n constructor(\n uint256 _auctionPeriod\n )\n public\n {\n auctionPeriod = _auctionPeriod;\n }\n\n /* ============ Internal Functions ============ */\n\n /**\n * Populates the linear auction struct following an auction initiation.\n *\n * @param _linearAuction LinearAuction State object\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @param _startingCurrentSetQuantity Quantity of currentSet to rebalance\n */\n function initializeLinearAuction(\n State storage _linearAuction,\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity\n )\n internal\n {\n initializeAuction(\n _linearAuction.auction,\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity\n );\n\n uint256 minimumBid = calculateMinimumBid(_linearAuction.auction, _currentSet, _nextSet);\n \n // remainingCurrentSets must be greater than minimumBid or no bidding would be allowed\n require(\n _startingCurrentSetQuantity.div(minimumBid) >= 100,\n \"LinearAuction.initializeAuction: Minimum bid must be less than or equal to 1% of collateral.\"\n );\n\n _linearAuction.auction.minimumBid = minimumBid;\n\n _linearAuction.startPrice = calculateStartPrice(_linearAuction.auction, _currentSet, _nextSet);\n _linearAuction.endPrice = calculateEndPrice(_linearAuction.auction, _currentSet, _nextSet);\n\n _linearAuction.endTime = block.timestamp.add(auctionPeriod);\n }\n\n /* ============ Internal View Functions ============ */\n\n /**\n * Returns the TokenFlow based on the current price\n */\n function getTokenFlow(\n State storage _linearAuction,\n uint256 _quantity\n )\n internal\n view\n returns (Rebalance.TokenFlow memory)\n {\n return Auction.calculateTokenFlow(\n _linearAuction.auction,\n _quantity,\n getPrice(_linearAuction)\n ); \n }\n\n /**\n * Auction failed is defined the timestamp breacnhing the auction end time and\n * the auction not being complete\n */\n function hasAuctionFailed(State storage _linearAuction) internal view returns(bool) {\n bool endTimeExceeded = block.timestamp >= _linearAuction.endTime;\n bool setsNotAuctioned = hasBiddableQuantity(_linearAuction.auction);\n\n return (endTimeExceeded && setsNotAuctioned); \n }\n\n /**\n * Returns the price based on the current timestamp. Returns the endPrice\n * if time has exceeded the auction period\n *\n * @param _linearAuction Linear Auction State object\n * @return price uint representing the current price\n */\n function getPrice(State storage _linearAuction) internal view returns (uint256) {\n uint256 elapsed = block.timestamp.sub(_linearAuction.auction.startTime);\n\n // If current time has elapsed \n if (elapsed >= auctionPeriod) {\n return _linearAuction.endPrice;\n } else {\n uint256 range = _linearAuction.endPrice.sub(_linearAuction.startPrice);\n uint256 elapsedPrice = elapsed.mul(range).div(auctionPeriod);\n\n return _linearAuction.startPrice.add(elapsedPrice);\n }\n }\n\n /**\n * Abstract function that must be implemented.\n * Calculate the minimumBid allowed for the rebalance.\n *\n * @param _auction Auction object\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @return Minimum bid amount\n */\n function calculateMinimumBid(\n Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns (uint256);\n\n /**\n * Abstract function that must be implemented.\n * Calculates the linear auction start price\n */\n function calculateStartPrice(\n Auction.Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns(uint256);\n\n /**\n * Abstract function that must be implemented.\n * Calculates the linear auction end price\n */\n function calculateEndPrice(\n Auction.Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns(uint256);\n}"
},
{
"path": "contracts/core/liquidators/impl/SetUSDValuation.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20Detailed } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol\";\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\nimport { IOracle } from \"set-protocol-oracles/contracts/meta-oracles/interfaces/IOracle.sol\";\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { IOracleWhiteList } from \"../../interfaces/IOracleWhiteList.sol\";\nimport { IRebalancingSetTokenV2 } from \"../../interfaces/IRebalancingSetTokenV2.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { SetMath } from \"../../lib/SetMath.sol\";\n\n\n/**\n * @title SetUSDValuation\n * @author Set Protocol\n *\n * Utility functions to derive the USD value of a Set and its components\n */\nlibrary SetUSDValuation {\n using SafeMath for uint256;\n using AddressArrayUtils for address[];\n\n uint256 constant public SET_FULL_UNIT = 10 ** 18;\n\n /* ============ SetToken Valuation Helpers ============ */\n\n\n /**\n * Calculates value of RebalancingSetToken.\n *\n * @return uint256 Streaming fee\n */\n function calculateRebalancingSetValue(\n address _rebalancingSetTokenAddress,\n IOracleWhiteList _oracleWhitelist\n )\n internal\n view\n returns (uint256)\n {\n IRebalancingSetTokenV2 rebalancingSetToken = IRebalancingSetTokenV2(_rebalancingSetTokenAddress);\n\n uint256 unitShares = rebalancingSetToken.unitShares();\n uint256 naturalUnit = rebalancingSetToken.naturalUnit();\n ISetToken currentSet = rebalancingSetToken.currentSet();\n\n // Calculate collateral value\n uint256 collateralValue = calculateSetTokenDollarValue(\n currentSet,\n _oracleWhitelist\n );\n\n // Value of rebalancing set is collateralValue times unitShares divided by naturalUnit\n return collateralValue.mul(unitShares).div(naturalUnit);\n }\n\n /*\n * Calculates the USD Value of a full unit Set Token\n *\n * @param _set Instance of SetToken\n * @param _oracleWhiteList Instance of oracle whitelist\n * @return uint256 The USD value of the Set (in cents)\n */\n function calculateSetTokenDollarValue(\n ISetToken _set,\n IOracleWhiteList _oracleWhitelist\n )\n internal\n view\n returns (uint256)\n {\n uint256 setDollarAmount = 0;\n\n address[] memory components = _set.getComponents();\n uint256[] memory units = _set.getUnits();\n uint256 naturalUnit = _set.naturalUnit();\n\n // Loop through assets\n for (uint256 i = 0; i < components.length; i++) {\n address currentComponent = components[i];\n\n address oracle = _oracleWhitelist.getOracleAddressByToken(currentComponent);\n uint256 price = IOracle(oracle).read();\n uint256 decimals = ERC20Detailed(currentComponent).decimals();\n\n // Calculate dollar value of single component in Set\n uint256 tokenDollarValue = calculateTokenAllocationAmountUSD(\n price,\n naturalUnit,\n units[i],\n decimals\n );\n\n // Add value of single component to running component value tally\n setDollarAmount = setDollarAmount.add(tokenDollarValue);\n }\n\n return setDollarAmount;\n }\n\n /*\n * Get USD value of one component in a Set to 18 decimals\n *\n * @param _tokenPrice The 18 decimal value of one full token\n * @param _naturalUnit The naturalUnit of the set being component belongs to\n * @param _unit The unit of the component in the set\n * @param _tokenDecimal The component token's decimal value\n * @return uint256 The USD value of the component's allocation in the Set\n */\n function calculateTokenAllocationAmountUSD(\n uint256 _tokenPrice,\n uint256 _naturalUnit,\n uint256 _unit,\n uint256 _tokenDecimal\n )\n internal\n pure\n returns (uint256)\n {\n uint256 tokenFullUnit = 10 ** _tokenDecimal;\n\n // Calculate the amount of component base units are in one full set token\n uint256 componentUnitsInFullToken = SetMath.setToComponent(\n SET_FULL_UNIT,\n _unit,\n _naturalUnit\n );\n \n // Return value of component token in one full set token, to 18 decimals\n uint256 allocationUSDValue = _tokenPrice\n .mul(componentUnitsInFullToken)\n .div(tokenFullUnit);\n\n require(\n allocationUSDValue > 0,\n \"SetUSDValuation.calculateTokenAllocationAmountUSD: Value must be > 0\"\n );\n\n return allocationUSDValue;\n }\n}"
},
{
"path": "contracts/core/liquidators/impl/TwoAssetPriceBoundedLinearAuction.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20Detailed } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol\";\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\nimport { IOracle } from \"set-protocol-oracles/contracts/meta-oracles/interfaces/IOracle.sol\";\n\nimport { Auction } from \"./Auction.sol\";\nimport { IOracleWhiteList } from \"../../interfaces/IOracleWhiteList.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { LinearAuction } from \"./LinearAuction.sol\";\n\n\n/**\n * @title TwoAssetPriceBoundedLinearAuction\n * @author Set Protocol\n *\n * Contract to calculate minimumBid and auction start bounds for auctions containing only\n * an asset pair.\n *\n * CHANGELOG: 5/20/2020 - Edited rangeStart and rangeEnd values to be scaled figures.\n */\ncontract TwoAssetPriceBoundedLinearAuction is LinearAuction {\n using SafeMath for uint256;\n using CommonMath for uint256;\n\n /* ============ Struct ============ */\n struct AssetInfo {\n uint256 price;\n uint256 fullUnit;\n }\n\n /* ============ Constants ============ */\n uint256 constant private CURVE_DENOMINATOR = 10 ** 18;\n uint256 constant private ONE = 1;\n // Minimum token flow allowed at spot price in auction\n uint256 constant private MIN_SPOT_TOKEN_FLOW_SCALED = 10 ** 21;\n\n /* ============ State Variables ============ */\n IOracleWhiteList public oracleWhiteList;\n uint256 public rangeStart; // Percentage below FairValue to begin auction at\n uint256 public rangeEnd; // Percentage above FairValue to end auction at\n\n /**\n * TwoAssetPriceBoundedLinearAuction constructor\n *\n * @param _auctionPeriod Length of auction\n * @param _rangeStart Percentage below FairValue to begin auction at in 18 decimal value\n * @param _rangeEnd Percentage above FairValue to end auction at in 18 decimal value\n */\n constructor(\n IOracleWhiteList _oracleWhiteList,\n uint256 _auctionPeriod,\n uint256 _rangeStart,\n uint256 _rangeEnd\n )\n public\n LinearAuction(_auctionPeriod)\n {\n oracleWhiteList = _oracleWhiteList;\n rangeStart = _rangeStart;\n rangeEnd = _rangeEnd;\n }\n\n /* ============ Internal Functions ============ */\n\n /**\n * Validates that the auction only includes two components and the components are valid.\n */\n function validateTwoAssetPriceBoundedAuction(\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n {\n address[] memory combinedTokenArray = Auction.getCombinedTokenArray(_currentSet, _nextSet);\n require(\n combinedTokenArray.length == 2,\n \"TwoAssetPriceBoundedLinearAuction: Only two components are allowed.\"\n );\n\n require(\n oracleWhiteList.areValidAddresses(combinedTokenArray),\n \"TwoAssetPriceBoundedLinearAuction: Passed token does not have matching oracle.\"\n );\n }\n\n /**\n * Calculates the minimumBid. First calculates the minimum token flow for the pair at fair value using\n * maximum natural unit of two Sets. If that token flow is below 1000 units then calculate minimumBid\n * as such:\n *\n * minimumBid = maxNaturalUnit*1000/min(tokenFlow)\n *\n * Else, set minimumBid equal to maxNaturalUnit. This is to ensure that around fair value there is ample\n * granualarity in asset pair price changes and not large discontinuities.\n *\n * @param _auction Auction object\n * @param _currentSet CurrentSet, unused in this implementation\n * @param _nextSet NextSet, unused in this implementation\n */\n function calculateMinimumBid(\n Auction.Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns (uint256)\n {\n // Get full Unit amount and price for each asset\n AssetInfo memory assetOne = getAssetInfo(_auction.combinedTokenArray[0]);\n AssetInfo memory assetTwo = getAssetInfo(_auction.combinedTokenArray[1]);\n\n // Calculate current spot price as assetOne/assetTwo\n uint256 spotPrice = calculateSpotPrice(assetOne.price, assetTwo.price);\n\n // Calculate auction price at current asset pair spot price\n uint256 auctionFairValue = convertAssetPairPriceToAuctionPrice(\n _auction,\n spotPrice,\n assetOne.fullUnit,\n assetTwo.fullUnit\n );\n\n uint256 minimumBidMultiplier = 0;\n for (uint8 i = 0; i < _auction.combinedTokenArray.length; i++) {\n // Get token flow at fair value for asset i, using an amount equal to ONE maxNaturalUnit\n // Hence the ONE.scale()\n (\n uint256 tokenInflowScaled,\n uint256 tokenOutflowScaled\n ) = Auction.calculateInflowOutflow(\n _auction.combinedCurrentSetUnits[i],\n _auction.combinedNextSetUnits[i],\n ONE.scale(),\n auctionFairValue\n );\n\n // One returned number from previous function will be zero so use max to get tokenFlow\n uint256 tokenFlowScaled = Math.max(tokenInflowScaled, tokenOutflowScaled);\n\n // Divide minimum spot token flow (1000 units) by token flow if more than minimumBidMultiplier\n // update minimumBidMultiplier\n uint256 currentMinBidMultiplier = MIN_SPOT_TOKEN_FLOW_SCALED.divCeil(tokenFlowScaled);\n minimumBidMultiplier = currentMinBidMultiplier > minimumBidMultiplier ?\n currentMinBidMultiplier :\n minimumBidMultiplier;\n }\n\n // Multiply the minimumBidMultiplier by maxNaturalUnit to get minimumBid\n return _auction.maxNaturalUnit.mul(minimumBidMultiplier);\n }\n\n /**\n * Calculates the linear auction start price. A target asset pair (i.e. ETH/DAI) price is calculated\n * to start the auction at, that asset pair price is then translated into the equivalent auction price.\n *\n * @param _auction Auction object\n * @param _currentSet CurrentSet, unused in this implementation\n * @param _nextSet NextSet, unused in this implementation\n */\n function calculateStartPrice(\n Auction.Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns(uint256)\n {\n // Get full Unit amount and price for each asset\n AssetInfo memory assetOne = getAssetInfo(_auction.combinedTokenArray[0]);\n AssetInfo memory assetTwo = getAssetInfo(_auction.combinedTokenArray[1]);\n\n // Calculate current asset pair spot price as assetOne/assetTwo\n uint256 spotPrice = calculateSpotPrice(assetOne.price, assetTwo.price);\n\n // Check to see if asset pair price is increasing or decreasing as time passes\n bool isTokenFlowIncreasing = isTokenFlowIncreasing(\n _auction,\n spotPrice,\n assetOne.fullUnit,\n assetTwo.fullUnit\n );\n\n // If price implied by token flows is increasing then target price we are using for lower bound\n // is below current spot price, if flows decreasing set target price above spotPrice\n uint256 startPairPrice;\n if (isTokenFlowIncreasing) {\n startPairPrice = spotPrice.mul(CommonMath.scaleFactor().sub(rangeStart)).deScale();\n } else {\n startPairPrice = spotPrice.mul(CommonMath.scaleFactor().add(rangeStart)).deScale();\n }\n\n // Convert start asset pair price to equivalent auction price\n return convertAssetPairPriceToAuctionPrice(\n _auction,\n startPairPrice,\n assetOne.fullUnit,\n assetTwo.fullUnit\n );\n }\n\n /**\n * Calculates the linear auction end price. A target asset pair (i.e. ETH/DAI) price is calculated\n * to end the auction at, that asset pair price is then translated into the equivalent auction price.\n *\n * @param _auction Auction object\n * @param _currentSet CurrentSet, unused in this implementation\n * @param _nextSet NextSet, unused in this implementation\n */\n function calculateEndPrice(\n Auction.Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns(uint256)\n {\n // Get full Unit amount and price for each asset\n AssetInfo memory assetOne = getAssetInfo(_auction.combinedTokenArray[0]);\n AssetInfo memory assetTwo = getAssetInfo(_auction.combinedTokenArray[1]);\n\n // Calculate current spot price as assetOne/assetTwo\n uint256 spotPrice = calculateSpotPrice(assetOne.price, assetTwo.price);\n\n // Check to see if asset pair price is increasing or decreasing as time passes\n bool isTokenFlowIncreasing = isTokenFlowIncreasing(\n _auction,\n spotPrice,\n assetOne.fullUnit,\n assetTwo.fullUnit\n );\n\n // If price implied by token flows is increasing then target price we are using for upper bound\n // is above current spot price, if flows decreasing set target price below spotPrice\n uint256 endPairPrice;\n if (isTokenFlowIncreasing) {\n endPairPrice = spotPrice.mul(CommonMath.scaleFactor().add(rangeEnd)).deScale();\n } else {\n endPairPrice = spotPrice.mul(CommonMath.scaleFactor().sub(rangeEnd)).deScale();\n }\n\n // Convert end asset pair price to equivalent auction price\n return convertAssetPairPriceToAuctionPrice(\n _auction,\n endPairPrice,\n assetOne.fullUnit,\n assetTwo.fullUnit\n );\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Determines if asset pair price is increasing or decreasing as time passed in auction. Used to set the\n * auction price bounds. Below a refers to any asset and subscripts c, n, d mean currentSetUnit, nextSetUnit\n * and fullUnit amount, respectively. pP and pD refer to auction price and auction denominator. Asset pair\n * price is defined as such:\n *\n * assetPrice = abs(assetTwoOutflow/assetOneOutflow)\n *\n * The equation for an outflow is given by (a_c/a_d)*pP - (a_n/a_d)*pD). It can be proven that the derivative\n * of this equation is always increasing. Thus by determining the sign of the assetOneOutflow (where a negative\n * amount signifies an inflow) it can be determined whether the asset pair price is increasing or decreasing.\n *\n * For example, if assetOneOutflow is negative it means that the denominator is getting smaller as time passes\n * and thus the assetPrice is increasing during the auction.\n *\n * @param _auction Auction object\n * @param _spotPrice Current spot price provided by asset oracles\n * @param _assetOneFullUnit Units in one full unit of assetOne\n * @param _assetTwoFullUnit Units in one full unit of assetTwo\n */\n function isTokenFlowIncreasing(\n Auction.Setup storage _auction,\n uint256 _spotPrice,\n uint256 _assetOneFullUnit,\n uint256 _assetTwoFullUnit\n )\n private\n view\n returns (bool)\n {\n // Calculate auction price at current asset pair spot price\n uint256 auctionFairValue = convertAssetPairPriceToAuctionPrice(\n _auction,\n _spotPrice,\n _assetOneFullUnit,\n _assetTwoFullUnit\n );\n\n // Determine whether outflow for assetOne is positive or negative, if positive then asset pair price is\n // increasing, else decreasing.\n return _auction.combinedNextSetUnits[0].mul(CURVE_DENOMINATOR) >\n _auction.combinedCurrentSetUnits[0].mul(auctionFairValue);\n }\n\n /**\n * Convert an asset pair price to the equivalent auction price where a1 refers to assetOne and a2 refers to assetTwo\n * and subscripts c, n, d mean currentSetUnit, nextSetUnit and fullUnit amount, respectively. pP and pD refer to auction\n * price and auction denominator:\n *\n * assetPrice = abs(assetTwoOutflow/assetOneOutflow)\n *\n * assetPrice = ((a2_c/a2_d)*pP - (a2_n/a2_d)*pD) / ((a1_c/a1_d)*pP - (a1_n/a1_d)*pD)\n *\n * We know assetPrice so we isolate for pP:\n *\n * pP = pD((a2_n/a2_d)+assetPrice*(a1_n/a1_d)) / (a2_c/a2_d)+assetPrice*(a1_c/a1_d)\n *\n * This gives us the auction price that matches with the passed asset pair price.\n *\n * @param _auction Auction object\n * @param _targetPrice Target asset pair price\n * @param _assetOneFullUnit Units in one full unit of assetOne\n * @param _assetTwoFullUnit Units in one full unit of assetTwo\n */\n function convertAssetPairPriceToAuctionPrice(\n Auction.Setup storage _auction,\n uint256 _targetPrice,\n uint256 _assetOneFullUnit,\n uint256 _assetTwoFullUnit\n )\n private\n view\n returns (uint256)\n {\n // Calculate the numerator for the above equation. In order to ensure no rounding down errors we distribute the auction\n // denominator. Additionally, since the price is passed as an 18 decimal number in order to maintain consistency we\n // have to scale the first term up accordingly\n uint256 calcNumerator = _auction.combinedNextSetUnits[1].mul(CURVE_DENOMINATOR).scale().div(_assetTwoFullUnit).add(\n _targetPrice.mul(_auction.combinedNextSetUnits[0]).mul(CURVE_DENOMINATOR).div(_assetOneFullUnit)\n );\n\n // Calculate the denominator for the above equation. As above we we have to scale the first term match the 18 decimal\n // price. Furthermore since we are not guaranteed that targetPrice * a1_c > a1_d we have to scale the second term and\n // thus also the first term in order to match (hence the two scale() in the first term)\n uint256 calcDenominator = _auction.combinedCurrentSetUnits[1].scale().scale().div(_assetTwoFullUnit).add(\n _targetPrice.mul(_auction.combinedCurrentSetUnits[0]).scale().div(_assetOneFullUnit)\n );\n\n // Here the scale required to account for the 18 decimal price cancels out since it was applied to both the numerator\n // and denominator. However, there was an extra scale applied to the denominator that we need to remove, in order to\n // do so we'll just apply another scale to the numerator before dividing since 1/(1/10 ** 18) = 10 ** 18!\n return calcNumerator.scale().div(calcDenominator);\n }\n\n /**\n * Get fullUnit amount and price of given asset.\n *\n * @param _asset Address of auction to get information from\n */\n function getAssetInfo(address _asset) private view returns(AssetInfo memory) {\n address assetOracle = oracleWhiteList.getOracleAddressByToken(_asset);\n uint256 assetPrice = IOracle(assetOracle).read();\n\n uint256 decimals = ERC20Detailed(_asset).decimals();\n\n return AssetInfo({\n price: assetPrice,\n fullUnit: CommonMath.safePower(10, decimals)\n });\n }\n\n /**\n * Calculate asset pair price given two prices.\n */\n function calculateSpotPrice(uint256 _assetOnePrice, uint256 _assetTwoPrice) private view returns(uint256) {\n return _assetOnePrice.scale().div(_assetTwoPrice);\n }\n}"
},
{
"path": "contracts/core/liquidators/twap-impl/TWAPAuction.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\nimport { BoundsLibrary } from \"set-protocol-contract-utils/contracts/lib/BoundsLibrary.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { Auction } from \"../impl/Auction.sol\";\nimport { LinearAuction } from \"../impl/LinearAuction.sol\";\nimport { LiquidatorUtils } from \"../utils/LiquidatorUtils.sol\";\nimport { IOracleWhiteList } from \"../../../core/interfaces/IOracleWhiteList.sol\";\nimport { ISetToken } from \"../../../core/interfaces/ISetToken.sol\";\nimport { IRebalancingSetTokenV3 } from \"../../../core/interfaces/IRebalancingSetTokenV3.sol\";\nimport { TwoAssetPriceBoundedLinearAuction } from \"../impl/TwoAssetPriceBoundedLinearAuction.sol\";\n\n\n/**\n * @title TWAPAuction\n * @author Set Protocol\n *\n * Contract for executing TWAP Auctions from initializing to moving to the next chunk auction. Inherits from\n * TwoAssetPriceBoundedLinearAuction\n */\ncontract TWAPAuction is TwoAssetPriceBoundedLinearAuction {\n using SafeMath for uint256;\n using CommonMath for uint256;\n using AddressArrayUtils for address[];\n using BoundsLibrary for BoundsLibrary.Bounds;\n\n /* ============ Structs ============ */\n\n struct TWAPState {\n LinearAuction.State chunkAuction; // Current chunk auction state\n uint256 orderSize; // Beginning amount of currentSets\n uint256 orderRemaining; // Amount of current Sets not auctioned or being auctioned\n uint256 lastChunkAuctionEnd; // Time of last chunk auction end\n uint256 chunkAuctionPeriod; // Time between chunk auctions\n uint256 chunkSize; // Amount of current Sets in a full chunk auction\n }\n\n struct TWAPLiquidatorData {\n uint256 chunkSizeValue; // Currency value of rebalance volume in each chunk (18 decimal)\n uint256 chunkAuctionPeriod; // Time between chunk auctions\n }\n\n struct AssetPairVolumeBounds {\n address assetOne; // Address of first asset in pair\n address assetTwo; // Address of second asset in pair\n BoundsLibrary.Bounds bounds; // Chunk size volume bounds for asset pair\n }\n\n /* ============ Constants ============ */\n\n // Auction completion buffer assumes completion potentially 2% after fair value when auction started\n uint256 constant public AUCTION_COMPLETION_BUFFER = 2e16;\n\n /* ============ State Variables ============ */\n\n // Mapping between an address pair's addresses and the min/max USD-chunk size, each asset pair will\n // have two entries, one for each ordering of the addresses\n mapping(address => mapping(address => BoundsLibrary.Bounds)) public chunkSizeWhiteList;\n //Estimated length in seconds of a chunk auction\n uint256 public expectedChunkAuctionLength;\n\n /* ============ Constructor ============ */\n\n /**\n * TWAPAuction constructor\n *\n * @param _oracleWhiteList OracleWhiteList used by liquidator\n * @param _auctionPeriod Length of auction in seconds\n * @param _rangeStart Percentage below FairValue to begin auction at in 18 decimal value\n * @param _rangeEnd Percentage above FairValue to end auction at in 18 decimal value\n * @param _assetPairVolumeBounds List of chunk size bounds for each asset pair\n */\n constructor(\n IOracleWhiteList _oracleWhiteList,\n uint256 _auctionPeriod,\n uint256 _rangeStart,\n uint256 _rangeEnd,\n AssetPairVolumeBounds[] memory _assetPairVolumeBounds\n )\n public\n TwoAssetPriceBoundedLinearAuction(\n _oracleWhiteList,\n _auctionPeriod,\n _rangeStart,\n _rangeEnd\n )\n {\n require(\n _rangeEnd >= AUCTION_COMPLETION_BUFFER,\n \"TWAPAuction.constructor: Passed range end must exceed completion buffer.\"\n );\n\n // Not using CommonMath.scaleFactoor() due to compilation issues related to constructor size\n require(\n _rangeEnd <= 1e18 && _rangeStart <= 1e18,\n \"TWAPAuction.constructor: Range bounds must be less than 100%.\"\n );\n\n for (uint256 i = 0; i < _assetPairVolumeBounds.length; i++) {\n BoundsLibrary.Bounds memory bounds = _assetPairVolumeBounds[i].bounds;\n\n // Not using native library due to compilation issues related to constructor size\n require(\n bounds.lower <= bounds.upper,\n \"TWAPAuction.constructor: Passed asset pair bounds are invalid.\"\n );\n\n address assetOne = _assetPairVolumeBounds[i].assetOne;\n address assetTwo = _assetPairVolumeBounds[i].assetTwo;\n\n require(\n chunkSizeWhiteList[assetOne][assetTwo].upper == 0,\n \"TWAPAuction.constructor: Asset pair volume bounds must be unique.\"\n );\n\n chunkSizeWhiteList[assetOne][assetTwo] = bounds;\n chunkSizeWhiteList[assetTwo][assetOne] = bounds;\n }\n\n // Expected length of a chunk auction, assuming the auction goes 2% beyond initial fair\n // value. Used to validate TWAP Auction length won't exceed Set's rebalanceFailPeriod.\n // Not using SafeMath due to compilation issues related to constructor size\n require(\n _auctionPeriod < -uint256(1) / (_rangeStart + AUCTION_COMPLETION_BUFFER),\n \"TWAPAuction.constructor: Auction period too long.\"\n );\n\n expectedChunkAuctionLength = _auctionPeriod * (_rangeStart + AUCTION_COMPLETION_BUFFER) /\n (_rangeStart + _rangeEnd);\n\n require(\n expectedChunkAuctionLength > 0,\n \"TWAPAuction.constructor: Expected auction length must exceed 0.\"\n );\n }\n\n /* ============ Internal Functions ============ */\n\n /**\n * Populates the TWAPState struct and initiates first chunk auction.\n *\n * @param _twapAuction TWAPAuction State object\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @param _startingCurrentSetQuantity Quantity of currentSet to rebalance\n * @param _chunkSizeValue Value of chunk size in terms of currency represented by\n * the oracleWhiteList\n * @param _chunkAuctionPeriod Time between chunk auctions\n */\n function initializeTWAPAuction(\n TWAPState storage _twapAuction,\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n uint256 _chunkSizeValue,\n uint256 _chunkAuctionPeriod\n )\n internal\n {\n // Initialize first chunk auction with the currentSetQuantity to populate LinearAuction struct\n // This will be overwritten by the initial chunk auction quantity\n LinearAuction.initializeLinearAuction(\n _twapAuction.chunkAuction,\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity\n );\n\n // Calculate currency value of rebalance volume\n uint256 rebalanceVolume = LiquidatorUtils.calculateRebalanceVolume(\n _currentSet,\n _nextSet,\n oracleWhiteList,\n _startingCurrentSetQuantity\n );\n\n // Calculate the size of each chunk auction in currentSet terms\n uint256 chunkSize = calculateChunkSize(\n _startingCurrentSetQuantity,\n rebalanceVolume,\n _chunkSizeValue\n );\n\n // Normalize the chunkSize and orderSize to ensure all values are a multiple of\n // the minimum bid\n uint256 minBid = _twapAuction.chunkAuction.auction.minimumBid;\n uint256 normalizedChunkSize = chunkSize.div(minBid).mul(minBid);\n uint256 totalOrderSize = _startingCurrentSetQuantity.div(minBid).mul(minBid);\n\n // Initialize the first chunkAuction to the normalized chunk size\n _twapAuction.chunkAuction.auction.startingCurrentSets = normalizedChunkSize;\n _twapAuction.chunkAuction.auction.remainingCurrentSets = normalizedChunkSize;\n\n // Set TWAPState\n _twapAuction.orderSize = totalOrderSize;\n _twapAuction.orderRemaining = totalOrderSize.sub(normalizedChunkSize);\n _twapAuction.chunkSize = normalizedChunkSize;\n _twapAuction.lastChunkAuctionEnd = 0;\n _twapAuction.chunkAuctionPeriod = _chunkAuctionPeriod;\n }\n\n /**\n * Calculates size of next chunk auction and then starts then parameterizes the auction and overwrites\n * the previous auction state. The orderRemaining is updated to take into account the currentSets included\n * in the new chunk auction. Function can only be called provided the following conditions have been met:\n * - Last chunk auction is finished (remainingCurrentSets < minimumBid)\n * - There is still more collateral to auction off\n * - The chunkAuctionPeriod has elapsed\n *\n * @param _twapAuction TWAPAuction State object\n */\n function auctionNextChunk(\n TWAPState storage _twapAuction\n )\n internal\n {\n // Add leftover current Sets from previous chunk auction to orderRemaining\n uint256 totalRemainingSets = _twapAuction.orderRemaining.add(\n _twapAuction.chunkAuction.auction.remainingCurrentSets\n );\n\n // Calculate next chunk auction size as min of chunkSize or orderRemaining\n uint256 nextChunkAuctionSize = Math.min(_twapAuction.chunkSize, totalRemainingSets);\n\n // Start new chunk auction by over writing previous auction state and decrementing orderRemaining\n overwriteChunkAuctionState(_twapAuction, nextChunkAuctionSize);\n _twapAuction.orderRemaining = totalRemainingSets.sub(nextChunkAuctionSize);\n }\n\n /* ============ Internal Helper Functions ============ */\n\n /**\n * Resets state for next chunk auction (except minimumBid and token flow arrays)\n *\n * @param _twapAuction TWAPAuction State object\n * @param _chunkAuctionSize Size of next chunk auction\n */\n function overwriteChunkAuctionState(\n TWAPState storage _twapAuction,\n uint256 _chunkAuctionSize\n )\n internal\n {\n _twapAuction.chunkAuction.auction.startingCurrentSets = _chunkAuctionSize;\n _twapAuction.chunkAuction.auction.remainingCurrentSets = _chunkAuctionSize;\n _twapAuction.chunkAuction.auction.startTime = block.timestamp;\n _twapAuction.chunkAuction.endTime = block.timestamp.add(auctionPeriod);\n\n // Since currentSet and nextSet param is not used in calculating start and end price on\n // TwoAssetPriceBoundedLinearAuction we can pass in zero addresses\n _twapAuction.chunkAuction.startPrice = calculateStartPrice(\n _twapAuction.chunkAuction.auction,\n ISetToken(address(0)),\n ISetToken(address(0))\n );\n _twapAuction.chunkAuction.endPrice = calculateEndPrice(\n _twapAuction.chunkAuction.auction,\n ISetToken(address(0)),\n ISetToken(address(0))\n );\n }\n\n /**\n * Validates that chunk size is within asset bounds and passed chunkAuctionLength\n * is unlikely to push TWAPAuction beyond rebalanceFailPeriod.\n *\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @param _startingCurrentSetQuantity Quantity of currentSet to rebalance\n * @param _chunkSizeValue Value of chunk size in terms of currency represented by\n * the oracleWhiteList\n * @param _chunkAuctionPeriod Time between chunk auctions\n */\n function validateLiquidatorData(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n uint256 _chunkSizeValue,\n uint256 _chunkAuctionPeriod\n )\n internal\n view\n {\n // Calculate currency value of rebalance volume\n uint256 rebalanceVolume = LiquidatorUtils.calculateRebalanceVolume(\n _currentSet,\n _nextSet,\n oracleWhiteList,\n _startingCurrentSetQuantity\n );\n\n BoundsLibrary.Bounds memory volumeBounds = getVolumeBoundsFromCollateral(_currentSet, _nextSet);\n\n validateTWAPParameters(\n _chunkSizeValue,\n _chunkAuctionPeriod,\n rebalanceVolume,\n volumeBounds\n );\n }\n\n /**\n * Validates passed in parameters for TWAP auction\n *\n * @param _chunkSizeValue Value of chunk size in terms of currency represented by\n * the oracleWhiteList\n * @param _chunkAuctionPeriod Time between chunk auctions\n * @param _rebalanceVolume Value of collateral being rebalanced\n * @param _assetPairVolumeBounds Volume bounds of asset pair\n */\n function validateTWAPParameters(\n uint256 _chunkSizeValue,\n uint256 _chunkAuctionPeriod,\n uint256 _rebalanceVolume,\n BoundsLibrary.Bounds memory _assetPairVolumeBounds\n )\n internal\n view\n {\n // Bounds and chunkSizeValue denominated in currency value\n require(\n _assetPairVolumeBounds.isWithin(_chunkSizeValue),\n \"TWAPAuction.validateTWAPParameters: Passed chunk size must be between bounds.\"\n );\n\n // Want to make sure that the expected length of the auction is less than the rebalanceFailPeriod\n // or else a legitimate auction could be failed. Calculated as such:\n // expectedTWAPTime = numChunkAuctions * expectedChunkAuctionLength + (numChunkAuctions - 1) *\n // chunkAuctionPeriod\n uint256 numChunkAuctions = _rebalanceVolume.divCeil(_chunkSizeValue);\n uint256 expectedTWAPAuctionTime = numChunkAuctions.mul(expectedChunkAuctionLength)\n .add(numChunkAuctions.sub(1).mul(_chunkAuctionPeriod));\n\n uint256 rebalanceFailPeriod = IRebalancingSetTokenV3(msg.sender).rebalanceFailPeriod();\n\n require(\n expectedTWAPAuctionTime < rebalanceFailPeriod,\n \"TWAPAuction.validateTWAPParameters: Expected auction duration exceeds allowed length.\"\n );\n }\n\n /**\n * The next chunk auction can begin when the previous auction has completed, there are still currentSets to\n * rebalance, and the auction period has elapsed.\n *\n * @param _twapAuction TWAPAuction State object\n */\n function validateNextChunkAuction(\n TWAPState storage _twapAuction\n )\n internal\n view\n {\n Auction.validateAuctionCompletion(_twapAuction.chunkAuction.auction);\n\n require(\n isRebalanceActive(_twapAuction),\n \"TWAPState.validateNextChunkAuction: TWAPAuction is finished.\"\n );\n\n require(\n _twapAuction.lastChunkAuctionEnd.add(_twapAuction.chunkAuctionPeriod) <= block.timestamp,\n \"TWAPState.validateNextChunkAuction: Not enough time elapsed from last chunk auction end.\"\n );\n }\n\n /**\n * Checks if the amount of Sets still to be auctioned (in aggregate) is greater than the minimumBid\n *\n * @param _twapAuction TWAPAuction State object\n */\n function isRebalanceActive(\n TWAPState storage _twapAuction\n )\n internal\n view\n returns (bool)\n {\n // Sum of remaining Sets in current chunk auction and order remaining\n uint256 totalRemainingSets = calculateTotalSetsRemaining(_twapAuction);\n\n // Check that total remaining sets is greater than minimumBid\n return totalRemainingSets >= _twapAuction.chunkAuction.auction.minimumBid;\n }\n\n /**\n * Calculates chunkSize of auction in current Set terms\n *\n * @param _totalSetAmount Total amount of Sets being auctioned\n * @param _rebalanceVolume The total currency value being auctioned\n * @param _chunkSizeValue Value of chunk size in currency terms\n */\n function calculateChunkSize(\n uint256 _totalSetAmount,\n uint256 _rebalanceVolume,\n uint256 _chunkSizeValue\n )\n internal\n view\n returns (uint256)\n {\n // Since solidity rounds down anything equal to 1 will require at least one auction\n // equal to the chunkSizeValue\n if (_rebalanceVolume.div(_chunkSizeValue) >= 1) {\n return _totalSetAmount.mul(_chunkSizeValue).div(_rebalanceVolume);\n } else {\n return _totalSetAmount;\n }\n }\n\n /**\n * Calculates the total remaining sets in the auction between the currently underway chunk auction and\n * the Sets that have yet to be included in a chunk auction.\n *\n * @param _twapAuction TWAPAuction State object\n */\n function calculateTotalSetsRemaining(TWAPAuction.TWAPState storage _twapAuction)\n internal\n view\n returns (uint256)\n {\n return _twapAuction.orderRemaining.add(_twapAuction.chunkAuction.auction.remainingCurrentSets);\n }\n\n /**\n * Returns asset pair volume bounds based on passed in collateral Sets.\n *\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n */\n function getVolumeBoundsFromCollateral(\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns (BoundsLibrary.Bounds memory)\n {\n // Get set components\n address[] memory currentSetComponents = _currentSet.getComponents();\n address[] memory nextSetComponents = _nextSet.getComponents();\n\n address firstComponent = currentSetComponents [0];\n address secondComponent = currentSetComponents.length > 1 ? currentSetComponents [1] :\n nextSetComponents [0] != firstComponent ? nextSetComponents [0] : nextSetComponents [1];\n\n return chunkSizeWhiteList[firstComponent][secondComponent];\n }\n\n function parseLiquidatorData(\n bytes memory _liquidatorData\n )\n internal\n pure\n returns (uint256, uint256)\n {\n return abi.decode(_liquidatorData, (uint256, uint256));\n }\n}"
},
{
"path": "contracts/core/liquidators/twap-impl/TWAPAuctionGetters.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { AuctionGetters } from \"../impl/AuctionGetters.sol\";\nimport { TWAPAuction } from \"./TWAPAuction.sol\";\n\n\n/**\n * @title TWAPAuctionGetters\n * @author Set Protocol\n *\n * Contract containing getters for receiving data from TWAPAuction.TWAPState struct. The twapAuction()\n * getter is implemented in the inheriting contract.\n */\ncontract TWAPAuctionGetters is AuctionGetters {\n using SafeMath for uint256;\n\n function getOrderSize(address _set) external view returns (uint256) {\n return twapAuction(_set).orderSize;\n }\n\n function getOrderRemaining(address _set) external view returns (uint256) {\n return twapAuction(_set).orderRemaining;\n }\n\n function getChunkSize(address _set) external view returns (uint256) {\n return twapAuction(_set).chunkSize;\n }\n\n function getChunkAuctionPeriod(address _set) external view returns (uint256) {\n return twapAuction(_set).chunkAuctionPeriod;\n }\n\n function getLastChunkAuctionEnd(address _set) external view returns (uint256) {\n return twapAuction(_set).lastChunkAuctionEnd;\n }\n\n function twapAuction(address _set) internal view returns(TWAPAuction.TWAPState storage);\n}"
},
{
"path": "contracts/core/liquidators/utils/LiquidatorUtils.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License,\n Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20Detailed } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\nimport { IOracle } from \"set-protocol-oracles/contracts/meta-oracles/interfaces/IOracle.sol\";\n\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { IOracleWhiteList } from \"../../interfaces/IOracleWhiteList.sol\";\nimport { SetUSDValuation } from \"../impl/SetUSDValuation.sol\";\n\n\n/**\n * @title LiquidatorUtils\n * @author Set Protocol\n *\n * Contract of generic utils functions that can be used by liquidators and supporting contracts.\n */\nlibrary LiquidatorUtils {\n using SafeMath for uint256;\n using CommonMath for uint256;\n\n /* ============ Internal Functions ============ */\n\n /**\n * Calculate the rebalance volume as the difference in allocation percentages between two, tw0-asset\n * allocations times market cap. This function only works for Sets containing the two same assets,\n * either explicitly or implicitly (one of the Sets has 0 allocation for one of the assets).\n *\n * rebalanceVolume = currentSetValue * currentSetQty * abs(currentSetAllocation-nextSetAllocation)\n *\n * @param _currentSet The Set to rebalance from\n * @param _nextSet The Set to rebalance to\n * @param _oracleWhiteList OracleWhiteList used for valuation\n * @param _currentSetQuantity Quantity of currentSet to rebalance\n * @return Rebalance volume\n */\n function calculateRebalanceVolume(\n ISetToken _currentSet,\n ISetToken _nextSet,\n IOracleWhiteList _oracleWhiteList,\n uint256 _currentSetQuantity\n )\n internal\n view\n returns (uint256)\n {\n // Calculate currency value of current set\n uint256 currentSetValue = SetUSDValuation.calculateSetTokenDollarValue(\n _currentSet,\n _oracleWhiteList\n );\n\n // Calculate allocationAsset's current set allocation in 18 decimal scaled percentage\n address allocationAsset = _currentSet.getComponents()[0];\n uint256 currentSetAllocation = calculateAssetAllocation(\n _currentSet,\n _oracleWhiteList,\n allocationAsset\n );\n\n // Calculate allocationAsset's next set allocation in 18 decimal scaled percentage. If asset is not\n // in nextSet, returns 0.\n uint256 nextSetAllocation = calculateAssetAllocation(\n _nextSet,\n _oracleWhiteList,\n allocationAsset\n );\n\n // Get allocation change\n uint256 allocationChange = currentSetAllocation > nextSetAllocation ?\n currentSetAllocation.sub(nextSetAllocation) :\n nextSetAllocation.sub(currentSetAllocation);\n\n // Return rebalance volume by multiplying allocationChange by Set market cap, deScaling to avoid\n // overflow potential, still have 18 decimals of precision\n return currentSetValue.mul(_currentSetQuantity).deScale().mul(allocationChange).deScale();\n }\n\n /**\n * Calculate the allocation percentage of passed asset in Set\n *\n * @param _setToken Set being evaluated\n * @param _oracleWhiteList OracleWhiteList used for valuation\n * @param _asset Asset that's allocation being calculated\n * @return 18 decimal scaled allocation percentage\n */\n function calculateAssetAllocation(\n ISetToken _setToken,\n IOracleWhiteList _oracleWhiteList,\n address _asset\n )\n internal\n view\n returns (uint256)\n {\n address[] memory components = _setToken.getComponents();\n\n // Get index of asset and return if asset in Set\n (\n uint256 assetIndex,\n bool isInSet\n ) = AddressArrayUtils.indexOf(components, _asset);\n\n // Calculate allocation of asset if multiple assets and asset is in Set\n if (isInSet && components.length > 1) {\n uint256 setNaturalUnit = _setToken.naturalUnit();\n uint256[] memory setUnits = _setToken.getUnits();\n\n uint256 assetValue;\n uint256 setValue = 0;\n for (uint256 i = 0; i < components.length; i++) {\n address currentComponent = components[i];\n\n address oracle = _oracleWhiteList.getOracleAddressByToken(currentComponent);\n uint256 price = IOracle(oracle).read();\n uint256 decimals = ERC20Detailed(currentComponent).decimals();\n\n // Calculate currency value of single component in Set\n uint256 componentValue = SetUSDValuation.calculateTokenAllocationAmountUSD(\n price,\n setNaturalUnit,\n setUnits[i],\n decimals\n );\n\n // Add currency value of single component to running currency value tally\n setValue = setValue.add(componentValue);\n if (i == assetIndex) {assetValue = componentValue;}\n }\n\n return assetValue.scale().div(setValue);\n } else {\n // Since Set only has one asset, if its included then must be 100% else 0%\n return isInSet ? CommonMath.scaleFactor() : 0;\n }\n }\n}"
},
{
"path": "contracts/core/modules/CTokenExchangeIssuanceModule.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\nimport { CompoundUtils } from \"set-protocol-contract-utils/contracts/lib/CompoundUtils.sol\";\n\nimport { CTokenWhiteListed } from \"./lib/CTokenWhiteListed.sol\";\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\nimport { ExchangeIssuanceLibrary } from \"./lib/ExchangeIssuanceLibrary.sol\";\nimport { ExchangeIssuanceModule } from \"./ExchangeIssuanceModule.sol\";\nimport { ICToken } from \"../interfaces/ICToken.sol\";\nimport { IAddressToAddressWhiteList } from \"../interfaces/IAddressToAddressWhiteList.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { SetTokenLibrary } from \"../lib/SetTokenLibrary.sol\";\n\n\n/**\n * @title CTokenExchangeIssuanceModule\n * @author Set Protocol\n *\n * The CTokenExchangeIssuanceModule facilitates the exchangeIssue and exchangeRedeem functions which allows\n * the issuance and redemption of Sets containing cTokens using exchange orders and Compound functions. \n * Note: This module is not compatible with Compound Ether (cETH).\n */\ncontract CTokenExchangeIssuanceModule is\n ExchangeIssuanceModule,\n CTokenWhiteListed\n{\n using SafeMath for uint256;\n\n /* ============ State Variables ============ */\n\n // Address of transferProxy\n address public transferProxy;\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for CTokenExchangeIssuanceModule\n *\n * @param _core The address of Core\n * @param _vault The address of Vault\n * @param _transferProxy The address of TransferProxy\n * @param _cTokenWhiteList The instance of cTokenWhiteList contract\n */\n constructor(\n address _core,\n address _vault,\n address _transferProxy,\n IAddressToAddressWhiteList _cTokenWhiteList\n )\n public\n ExchangeIssuanceModule(\n _core,\n _vault\n )\n CTokenWhiteListed(\n _transferProxy,\n _cTokenWhiteList\n )\n {\n transferProxy = _transferProxy;\n }\n\n /* ============ Public Functions ============ */\n\n /**\n * Performs trades via exchange wrappers to acquire components, mints cToken from underlying, and issues a Set to the caller\n *\n * @param _exchangeIssuanceParams A Struct containing exchange issuance metadata\n * @param _orderData Bytes array containing the exchange orders to execute\n */\n function exchangeIssue(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData\n )\n public\n nonReentrant\n {\n // Validate the issuance quantity, send token and receive token data\n validateExchangeIssuanceParams(_exchangeIssuanceParams);\n\n // Validate that all receiveTokens are components of the Set\n SetTokenLibrary.validateTokensAreComponents(\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.receiveTokens\n );\n\n // Transfer the send tokens to the appropriate exchanges\n transferSendTokensToExchangeWrappers(\n _exchangeIssuanceParams.sendTokenExchangeIds,\n _exchangeIssuanceParams.sendTokens,\n _exchangeIssuanceParams.sendTokenAmounts\n );\n\n // Calculate expected receive token balances\n uint256[] memory requiredBalances = calculateReceiveTokenBalances(\n _exchangeIssuanceParams\n );\n\n // Execute the exchange orders using the encoded order data and deposits tokens in vault\n executeExchangeOrders(_orderData);\n\n // Withdraw underlying tokens required from vault, mint cTokens in the module, and return to vault under sender address\n mintCTokensFromExchangedComponents(\n _exchangeIssuanceParams.receiveTokens,\n _exchangeIssuanceParams.receiveTokenAmounts\n );\n\n // Check that sender's receive token balances in Vault are correct\n ExchangeIssuanceLibrary.validatePostExchangeReceiveTokenBalances(\n vault,\n _exchangeIssuanceParams.receiveTokens,\n requiredBalances,\n msg.sender\n );\n\n // Transfer remaining required underlying components from caller to module, mint cTokens and deposit in vault to caller\n mintCTokensFromCaller(\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.quantity\n );\n\n // Issue Set to the caller\n coreInstance.issueModule(\n msg.sender,\n msg.sender,\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.quantity\n );\n\n emit LogExchangeIssue(\n _exchangeIssuanceParams.setAddress,\n msg.sender,\n _exchangeIssuanceParams.quantity,\n _exchangeIssuanceParams.sendTokens,\n _exchangeIssuanceParams.sendTokenAmounts\n );\n }\n\n /**\n * Redeems a Set, redeems cToken to underlying, and performs trades via exchange wrappers for specified receive tokens.\n * The receive tokens are attributed to the caller.\n *\n * @param _exchangeIssuanceParams A Struct containing exchange issuance metadata\n * @param _orderData Bytes array containing the exchange orders to execute\n */\n function exchangeRedeem(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData\n )\n public\n nonReentrant\n {\n // Validate exchangeIssuanceParams\n validateExchangeIssuanceParams(_exchangeIssuanceParams);\n\n // Validate that all sendTokens are components of the Set\n SetTokenLibrary.validateTokensAreComponents(\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.sendTokens\n );\n\n // Redeem Set into the vault, attributing components to this contract\n coreInstance.redeemModule(\n msg.sender,\n address(this),\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.quantity\n );\n\n // Calculate expected receive token balances\n uint256[] memory requiredBalances = calculateReceiveTokenBalances(\n _exchangeIssuanceParams\n );\n\n // Withdraw underlying tokens required, redeem cTokens in the module, and send to exchange wrapper\n redeemCTokensAndTransferToExchangeWrappers(\n _exchangeIssuanceParams.sendTokenExchangeIds,\n _exchangeIssuanceParams.sendTokens,\n _exchangeIssuanceParams.sendTokenAmounts\n );\n\n // Execute the exchange orders using the encoded order data and deposits tokens in vault\n executeExchangeOrders(_orderData);\n\n // Check that sender's receive token balances in Vault are correct\n ExchangeIssuanceLibrary.validatePostExchangeReceiveTokenBalances(\n vault,\n _exchangeIssuanceParams.receiveTokens,\n requiredBalances,\n msg.sender\n );\n\n // Withdraw receive tokens from the Vault to the user\n coreInstance.batchWithdrawModule(\n msg.sender,\n msg.sender,\n _exchangeIssuanceParams.receiveTokens,\n _exchangeIssuanceParams.receiveTokenAmounts\n );\n\n // Withdraw any remaining non-exchanged components to the user\n withdrawRemainingComponentsToUser(_exchangeIssuanceParams.setAddress);\n\n emit LogExchangeRedeem(\n _exchangeIssuanceParams.setAddress,\n msg.sender,\n _exchangeIssuanceParams.quantity,\n _exchangeIssuanceParams.receiveTokens,\n _exchangeIssuanceParams.receiveTokenAmounts\n );\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Withdraw required underlying from vault, mint required amount of cTokens, and deposit back into vault\n *\n * @param _receiveTokens Array of SetToken component addresses to receive\n * @param _receiveTokenAmounts Array of SetToken component required quantities to receive\n */\n function mintCTokensFromExchangedComponents(\n address[] memory _receiveTokens,\n uint256[] memory _receiveTokenAmounts\n )\n private\n {\n for (uint256 i = 0; i < _receiveTokens.length; i++) {\n address currentComponentAddress = _receiveTokens[i];\n uint256 currentComponentQuantity = _receiveTokenAmounts[i];\n\n // If cToken, calculate required underlying tokens and transfer to module\n address underlyingAddress = cTokenWhiteList.whitelist(currentComponentAddress);\n if (underlyingAddress != address(0)) {\n ICToken cTokenInstance = ICToken(currentComponentAddress);\n\n // Calculate required amount of underlying. Calculated as cToken quantity * exchangeRate / 10 ** 18.\n uint256 exchangeRate = cTokenInstance.exchangeRateCurrent();\n uint256 underlyingQuantity = CompoundUtils.convertCTokenToUnderlying(currentComponentQuantity, exchangeRate);\n\n // Withdraw send tokens from vault (owned by order sender) to the module\n coreInstance.withdrawModule(\n msg.sender,\n address(this),\n underlyingAddress,\n underlyingQuantity\n );\n\n // Mint cToken and deposit to vault under sender\n mintCToken(cTokenInstance, underlyingAddress, underlyingQuantity);\n }\n }\n }\n\n /**\n * Transfer non-exchanged underlying tokens from caller, mint cTokens and deposit to the Vault under sender\n * to the caller\n *\n * @param _setAddress Address of the Set\n * @param _quantity Quantity of the Set to issue\n */\n function mintCTokensFromCaller(\n address _setAddress,\n uint256 _quantity\n )\n private\n {\n // Get SetToken details\n ISetToken baseSet = ISetToken(_setAddress);\n\n address[] memory baseSetComponents = baseSet.getComponents();\n uint256[] memory baseSetUnits = baseSet.getUnits();\n uint256 baseSetNaturalUnit = baseSet.naturalUnit();\n\n // Calculate the number of natural units required. Note: validateExchangeIssuanceParams ensures quantity is a\n // multiple of natural unit\n uint256 quantityOfNaturalUnits = _quantity.div(baseSetNaturalUnit);\n\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n address currentComponentAddress = baseSetComponents[i];\n // Get existing component quantity in the vault\n uint256 currentComponentQuantity = vaultInstance.getOwnerBalance(currentComponentAddress, msg.sender);\n\n // Calculate required quantity for component\n uint256 requiredQuantity = quantityOfNaturalUnits.mul(baseSetUnits[i]);\n\n // If cToken and balance of cToken in vault is less than required for issuing the Set\n // transfer difference from user and mint cToken\n address underlyingAddress = cTokenWhiteList.whitelist(currentComponentAddress);\n if (underlyingAddress != address(0) && currentComponentQuantity < requiredQuantity) {\n // Calculate amount of remaining cTokens needed to issue Set\n uint256 quantityToMint = requiredQuantity - currentComponentQuantity;\n\n ICToken cTokenInstance = ICToken(currentComponentAddress);\n\n // Calculate required amount of underlying. Calculated as cToken quantity * exchangeRate / 10 ** 18.\n uint256 exchangeRate = cTokenInstance.exchangeRateCurrent();\n uint256 underlyingQuantity = CompoundUtils.convertCTokenToUnderlying(quantityToMint, exchangeRate);\n\n // Transfer underlying from caller to module\n coreInstance.transferModule(\n underlyingAddress,\n underlyingQuantity,\n msg.sender,\n address(this)\n );\n\n // Mint cToken and deposit to vault under sender\n mintCToken(cTokenInstance, underlyingAddress, underlyingQuantity);\n }\n }\n }\n\n /**\n * Withdraw required underlying from vault, redeem required amount of cTokens, and transfer to exchange wrappers\n *\n * @param _sendTokenExchangeIds List of exchange wrapper enumerations corresponding to\n * @param _sendTokens Array of SetToken component addresses to send\n * @param _sendTokenAmounts Array of SetToken component required quantities to send\n */\n function redeemCTokensAndTransferToExchangeWrappers(\n uint8[] memory _sendTokenExchangeIds,\n address[] memory _sendTokens,\n uint256[] memory _sendTokenAmounts\n )\n private\n {\n for (uint256 i = 0; i < _sendTokens.length; i++) {\n address exchangeWrapper = coreInstance.exchangeIds(_sendTokenExchangeIds[i]);\n address currentComponentAddress = _sendTokens[i];\n uint256 currentComponentQuantity = _sendTokenAmounts[i];\n\n // If cToken redeem cToken and replace send token and amounts with underlying\n address underlyingAddress = cTokenWhiteList.whitelist(currentComponentAddress);\n if (underlyingAddress != address(0)) {\n // Withdraw cToken send tokens from vault (owned by this contract) to the module and redeem cToken\n redeemCToken(\n ICToken(currentComponentAddress),\n currentComponentQuantity\n );\n\n // Get balance of underlying in the contract after cToken redemption to ensure tokens are flushed\n uint256 underlyingQuantity = ERC20Wrapper.balanceOf(\n underlyingAddress,\n address(this)\n );\n\n // Ensure unlimited allowance for underlying component to transferProxy.\n ERC20Wrapper.ensureAllowance(\n underlyingAddress, // Token\n address(this), // Owner\n transferProxy, // Spender\n underlyingQuantity // Set unlimited if allowance less than quantity\n );\n\n // Transfer send tokens to the appropriate exchange wrapper\n coreInstance.transferModule(\n underlyingAddress, // Token\n underlyingQuantity, // Quantity\n address(this), // From address\n exchangeWrapper // To address\n );\n } else {\n // Withdraw non cToken send tokens from vault (owned by this contract) to the appropriate exchange wrapper\n coreInstance.withdrawModule(\n address(this), // From address in vault\n exchangeWrapper, // To address\n currentComponentAddress, // Token address\n currentComponentQuantity // Token quantity\n );\n }\n }\n }\n\n /**\n * Mint cToken and deposit in vault under sender\n *\n * @param _cToken Instance of cToken component to mint\n * @param _underlyingAddress Underlying component address\n * @param _underlyingQuantity Quantity of underlying to mint\n */\n function mintCToken(\n ICToken _cToken,\n address _underlyingAddress,\n uint256 _underlyingQuantity\n )\n private\n {\n // Ensure unlimited allowance for underlying token to cToken contract.\n ERC20Wrapper.ensureAllowance(\n _underlyingAddress,\n address(this),\n address(_cToken),\n _underlyingQuantity\n );\n\n // Mint cToken using underlying\n uint256 mintResponse = _cToken.mint(_underlyingQuantity);\n require(\n mintResponse == 0,\n \"CTokenExchangeIssuanceModule.mintCToken: Error minting cToken\"\n );\n\n // Get balance of cTokens minted in the contract to ensure tokens are flushed at the end\n uint256 cTokenQuantity = ERC20Wrapper.balanceOf(\n address(_cToken),\n address(this)\n );\n\n // Ensure unlimited allowance for cToken to transferProxy. This is for the case if we add a new cToken to the whitelist\n ERC20Wrapper.ensureAllowance(\n address(_cToken),\n address(this),\n transferProxy,\n cTokenQuantity\n );\n\n // Deposit transformed cTokens to vault (owned by order sender)\n coreInstance.depositModule(\n address(this),\n msg.sender,\n address(_cToken),\n cTokenQuantity\n );\n }\n\n /**\n * Withdraw cToken from vault, and redeem cToken in module\n *\n * @param _cToken Instance of cToken component to redeem\n * @param _cTokenQuantity Quantity of cToken to redeem\n */\n function redeemCToken(\n ICToken _cToken,\n uint256 _cTokenQuantity\n )\n private\n {\n // Withdraw cToken send tokens from vault (owned by this contract) to the module\n coreInstance.withdrawModule(\n address(this), // From address in vault\n address(this), // To address\n address(_cToken), // Token address\n _cTokenQuantity // Token quantity\n );\n\n // Redeem cToken to underlying\n uint256 redeemResponse = _cToken.redeem(_cTokenQuantity);\n require(\n redeemResponse == 0,\n \"CTokenExchangeIssuanceModule.redeemCToken: Error redeeming cToken\"\n );\n }\n\n /**\n * Transfers send tokens from the user to the appropriate exchange wrapper. Used in exchange issue\n *\n * @param _sendTokenExchangeIds List of exchange wrapper enumerations corresponding to\n * the wrapper that will handle the component\n * @param _sendTokens Array of addresses of the payment tokens\n * @param _sendTokenAmounts Array of amounts of payment Tokens\n */\n function transferSendTokensToExchangeWrappers(\n uint8[] memory _sendTokenExchangeIds,\n address[] memory _sendTokens,\n uint256[] memory _sendTokenAmounts\n )\n private\n {\n for (uint256 i = 0; i < _sendTokens.length; i++) {\n // Get exchange address from state mapping based on header exchange info\n address exchangeWrapper = coreInstance.exchangeIds(_sendTokenExchangeIds[i]);\n\n // Transfer send tokens to the appropriate exchange wrapper\n coreInstance.transferModule(\n _sendTokens[i],\n _sendTokenAmounts[i],\n msg.sender,\n exchangeWrapper\n );\n }\n }\n\n /**\n * Withdraws any remaining un-exchanged cToken and non cToken components from the Vault in the possession of this contract\n * to the caller\n *\n * @param _setAddress Address of the Base Set\n */\n function withdrawRemainingComponentsToUser(\n address _setAddress\n )\n private\n {\n address[] memory baseSetComponents = ISetToken(_setAddress).getComponents();\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n address currentComponentAddress = baseSetComponents[i];\n uint256 currentComponentQuantity = vaultInstance.getOwnerBalance(currentComponentAddress, address(this));\n\n // Remaining cTokens are redeemed to underlying and all tokens are sent to the caller\n if (currentComponentQuantity > 0) {\n address underlyingAddress = cTokenWhiteList.whitelist(currentComponentAddress);\n if (underlyingAddress != address(0)) {\n // Withdraw cToken send tokens from vault (owned by this contract) to the module and redeem\n redeemCToken(\n ICToken(currentComponentAddress),\n currentComponentQuantity\n );\n\n // Get balance of underlying after cToken redemption.\n uint256 underlyingQuantity = ERC20Wrapper.balanceOf(\n underlyingAddress,\n address(this)\n );\n\n // Ensure allowance for underlying component to transferProxy.\n ERC20Wrapper.ensureAllowance(\n underlyingAddress,\n address(this),\n transferProxy,\n underlyingQuantity\n );\n\n // Transfer underlying components to caller\n coreInstance.transferModule(\n underlyingAddress,\n underlyingQuantity,\n address(this),\n msg.sender\n );\n } else {\n // Return the unexchanged non cToken components to the caller\n coreInstance.withdrawModule(\n address(this),\n msg.sender,\n currentComponentAddress,\n currentComponentQuantity\n );\n }\n }\n }\n }\n}"
},
{
"path": "contracts/core/modules/ExchangeIssuanceModule.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ExchangeExecution } from \"./lib/ExchangeExecution.sol\";\nimport { ExchangeIssuanceLibrary } from \"./lib/ExchangeIssuanceLibrary.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { ModuleCoreState } from \"./lib/ModuleCoreState.sol\";\nimport { SetTokenLibrary } from \"../lib/SetTokenLibrary.sol\";\n\n\n/**\n * @title ExchangeIssuanceModule\n * @author Set Protocol\n *\n * The ExchangeIssuanceModule facilitates the exchangeIssue and exchangeRedeem functions which allows\n * the issuance and redemption Sets using exchange orders\n */\ncontract ExchangeIssuanceModule is\n ModuleCoreState,\n ExchangeExecution,\n ReentrancyGuard\n{\n using SafeMath for uint256;\n\n /* ============ Events ============ */\n\n event LogExchangeIssue(\n address setAddress,\n address indexed callerAddress,\n uint256 quantity,\n address[] sendTokens,\n uint256[] sendTokenAmounts\n );\n\n event LogExchangeRedeem(\n address setAddress,\n address indexed callerAddress,\n uint256 quantity,\n address[] receiveTokens,\n uint256[] receiveTokenAmounts\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for ExchangeIssuanceModule\n *\n * @param _core The address of Core\n * @param _vault The address of Vault\n */\n constructor(\n address _core,\n address _vault\n )\n public\n ModuleCoreState(\n _core,\n _vault\n )\n {}\n\n /* ============ Public Functions ============ */\n\n /**\n * Performs trades via exchange wrappers to acquire components and issues a Set to the caller\n *\n * @param _exchangeIssuanceParams A Struct containing exchange issuance metadata\n * @param _orderData Bytes array containing the exchange orders to execute\n */\n function exchangeIssue(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData\n )\n public\n nonReentrant\n {\n // Ensures validity of exchangeIssuanceParams\n validateExchangeIssuanceParams(_exchangeIssuanceParams);\n\n // Validate that all receiveTokens are components of the SEt\n SetTokenLibrary.validateTokensAreComponents(\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.receiveTokens\n );\n\n // Transfer the send tokens to the appropriate exchanges\n transferSendTokensToExchangeWrappers(\n _exchangeIssuanceParams.sendTokenExchangeIds,\n _exchangeIssuanceParams.sendTokens,\n _exchangeIssuanceParams.sendTokenAmounts\n );\n\n // Execute the exchange orders using the encoded order data\n executeOrders(_exchangeIssuanceParams, _orderData);\n\n // Issue Set to the caller\n coreInstance.issueModule(\n msg.sender,\n msg.sender,\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.quantity\n );\n\n emit LogExchangeIssue(\n _exchangeIssuanceParams.setAddress,\n msg.sender,\n _exchangeIssuanceParams.quantity,\n _exchangeIssuanceParams.sendTokens,\n _exchangeIssuanceParams.sendTokenAmounts\n );\n }\n\n /**\n * Redeems a Set and performs trades via exchange wrappers for specified receive tokens. The receive\n * tokens are attributed to the caller.\n * \n * @param _exchangeIssuanceParams A Struct containing exchange issuance metadata\n * @param _orderData Bytes array containing the exchange orders to execute\n */\n function exchangeRedeem(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData\n )\n public\n nonReentrant\n {\n // Validate exchangeIssuanceParams\n validateExchangeIssuanceParams(_exchangeIssuanceParams);\n\n // Validate that all sendTokens are components of the Set\n SetTokenLibrary.validateTokensAreComponents(\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.sendTokens\n );\n\n // Redeem Set into the vault, attributing components to this contract\n coreInstance.redeemModule(\n msg.sender,\n address(this),\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.quantity\n );\n\n // Transfer the send tokens to the appropriate exchanges\n withdrawSendTokensFromVaultToExchangeWrappers(\n _exchangeIssuanceParams.sendTokenExchangeIds,\n _exchangeIssuanceParams.sendTokens,\n _exchangeIssuanceParams.sendTokenAmounts\n );\n\n // Executes the orders, depositing tokens into the Vault to the user\n executeOrders(_exchangeIssuanceParams, _orderData);\n\n // Withdraw receive tokens from the Vault to the user\n coreInstance.batchWithdrawModule(\n msg.sender,\n msg.sender,\n _exchangeIssuanceParams.receiveTokens,\n _exchangeIssuanceParams.receiveTokenAmounts\n );\n\n // Withdraw any remaining non-exchanged components to the user\n withdrawRemainingComponentsToUser(_exchangeIssuanceParams.setAddress);\n\n emit LogExchangeRedeem(\n _exchangeIssuanceParams.setAddress,\n msg.sender,\n _exchangeIssuanceParams.quantity,\n _exchangeIssuanceParams.receiveTokens,\n _exchangeIssuanceParams.receiveTokenAmounts\n );\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Calculates required tokens to receive, executes orders, and checks post-exchange receive balances.\n *\n * @param _exchangeIssuanceParams A Struct containing exchange issuance metadata\n * @param _orderData Bytes array containing the exchange orders to execute\n */\n function executeOrders(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData\n )\n private\n {\n // Calculate expected receive token balances after exchange orders executed\n uint256[] memory requiredBalances = calculateReceiveTokenBalances(\n _exchangeIssuanceParams\n );\n\n // Execute exchange orders\n executeExchangeOrders(_orderData);\n\n // Check that sender's receive tokens in Vault have been incremented correctly\n ExchangeIssuanceLibrary.validatePostExchangeReceiveTokenBalances(\n vault,\n _exchangeIssuanceParams.receiveTokens,\n requiredBalances,\n msg.sender\n );\n }\n\n /**\n * Transfers send tokens from the user to the appropriate exchange wrapper. Used in exchange\n * issue.\n *\n * @param _sendTokenExchangeIds List of exchange wrapper enumerations corresponding to \n * the wrapper that will handle the component\n * @param _sendTokens Array of addresses of the payment tokens\n * @param _sendTokenAmounts Array of amounts of payment Tokens\n */\n function transferSendTokensToExchangeWrappers(\n uint8[] memory _sendTokenExchangeIds,\n address[] memory _sendTokens,\n uint256[] memory _sendTokenAmounts\n )\n private\n {\n for (uint256 i = 0; i < _sendTokens.length; i++) {\n // Get exchange wrapper address from state mapping based on enumeration\n address exchangeWrapper = coreInstance.exchangeIds(_sendTokenExchangeIds[i]);\n\n // Transfer send tokens to the appropriate exchange wrapper\n coreInstance.transferModule(\n _sendTokens[i],\n _sendTokenAmounts[i],\n msg.sender,\n exchangeWrapper\n );\n }\n }\n\n /**\n * Transfers send tokens from the Vault to the appropriate exchange wrappers. Used in\n * exchange redeem.\n *\n * @param _sendTokenExchangeIds List of exchange wrapper enumerations corresponding to \n * the wrapper that will handle the component\n * @param _sendTokens Array of addresses of the payment tokens\n * @param _sendTokenAmounts Array of amounts of payment Tokens\n */\n function withdrawSendTokensFromVaultToExchangeWrappers(\n uint8[] memory _sendTokenExchangeIds,\n address[] memory _sendTokens,\n uint256[] memory _sendTokenAmounts\n )\n private\n {\n for (uint256 i = 0; i < _sendTokens.length; i++) {\n // Get exchange address from state mapping based on header exchange info\n address exchangeWrapper = coreInstance.exchangeIds(_sendTokenExchangeIds[i]);\n\n // Withdraw send tokens from vault (owned by this contract) to the appropriate exchange wrapper\n coreInstance.withdrawModule(\n address(this),\n exchangeWrapper,\n _sendTokens[i],\n _sendTokenAmounts[i]\n );\n }\n }\n\n /**\n * Withdraws any remaining un-exchanged components from the Vault in the posession of this contract\n * to the caller\n *\n * @param _setAddress Address of the Base Set\n */\n function withdrawRemainingComponentsToUser(\n address _setAddress\n )\n private\n {\n address[] memory baseSetComponents = ISetToken(_setAddress).getComponents();\n uint256[] memory baseSetWithdrawQuantities = new uint256[](baseSetComponents.length);\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n uint256 withdrawQuantity = vaultInstance.getOwnerBalance(baseSetComponents[i], address(this));\n if (withdrawQuantity > 0) {\n baseSetWithdrawQuantities[i] = withdrawQuantity; \n }\n }\n\n // Return the unexchanged components to the user\n coreInstance.batchWithdrawModule(\n address(this),\n msg.sender,\n baseSetComponents,\n baseSetWithdrawQuantities\n ); \n }\n}\n"
},
{
"path": "contracts/core/modules/RebalanceAuctionModule.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IRebalancingSetToken } from \"../interfaces/IRebalancingSetToken.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\nimport { ModuleCoreState } from \"./lib/ModuleCoreState.sol\";\n\n\n/**\n * @title RebalanceAuctionModule\n * @author Set Protocol\n *\n * The RebalanceAuctionModule is a smart contract that exposes bidding and failed rebalance functionality.\n */\ncontract RebalanceAuctionModule is\n ModuleCoreState,\n ReentrancyGuard\n{\n using SafeMath for uint256;\n\n /* ============ Events ============ */\n\n event BidPlaced(\n address indexed rebalancingSetToken,\n address indexed bidder,\n uint256 executionQuantity,\n address[] combinedTokenAddresses,\n uint256[] inflowTokenUnits,\n uint256[] outflowTokenUnits\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for RebalanceAuctionModule\n *\n * @param _core The address of Core\n * @param _vault The address of Vault\n */\n constructor(\n address _core,\n address _vault\n )\n public\n ModuleCoreState(\n _core,\n _vault\n )\n {}\n\n /* ============ Public Functions ============ */\n\n /**\n * Bid on rebalancing a given quantity of sets held by a rebalancing token\n * The tokens are attributed to the user in the vault.\n *\n * @param _rebalancingSetToken Address of the rebalancing token being bid on\n * @param _quantity Number of currentSets to rebalance\n * @param _allowPartialFill Set to true if want to partially fill bid when quantity\n is greater than currentRemainingSets\n */\n function bid(\n address _rebalancingSetToken,\n uint256 _quantity,\n bool _allowPartialFill\n )\n external\n nonReentrant\n {\n // If user allows partial fills calculate partial fill (if necessary)\n uint256 executionQuantity = calculateExecutionQuantity(\n _rebalancingSetToken,\n _quantity,\n _allowPartialFill\n );\n\n // Place bid and retrieve token inflows and outflows\n address[] memory tokenArray;\n uint256[] memory inflowUnitArray;\n uint256[] memory outflowUnitArray;\n (\n tokenArray,\n inflowUnitArray,\n outflowUnitArray\n ) = IRebalancingSetToken(_rebalancingSetToken).placeBid(executionQuantity);\n\n // Retrieve tokens from bidder and deposit in vault for rebalancing set token\n coreInstance.batchDepositModule(\n msg.sender,\n _rebalancingSetToken,\n tokenArray,\n inflowUnitArray\n );\n\n // Transfer ownership of tokens in vault from rebalancing set token to bidder\n coreInstance.batchTransferBalanceModule(\n tokenArray,\n _rebalancingSetToken,\n msg.sender,\n outflowUnitArray\n );\n\n // Log bid placed event\n emit BidPlaced(\n _rebalancingSetToken,\n msg.sender,\n executionQuantity,\n tokenArray,\n inflowUnitArray,\n outflowUnitArray\n );\n }\n\n /**\n * Bid on rebalancing a given quantity of sets held by a rebalancing token\n * The tokens are returned to the user.\n *\n * @param _rebalancingSetToken Address of the rebalancing token being bid on\n * @param _quantity Number of currentSets to rebalance\n * @param _allowPartialFill Set to true if want to partially fill bid when quantity\n is greater than currentRemainingSets\n */\n function bidAndWithdraw(\n address _rebalancingSetToken,\n uint256 _quantity,\n bool _allowPartialFill\n )\n external\n nonReentrant\n {\n // If user allows partial fills calculate partial fill (if necessary)\n uint256 executionQuantity = calculateExecutionQuantity(\n _rebalancingSetToken,\n _quantity,\n _allowPartialFill\n );\n\n // Place bid and retrieve token inflows and outflows\n address[] memory tokenArray;\n uint256[] memory inflowUnitArray;\n uint256[] memory outflowUnitArray;\n (\n tokenArray,\n inflowUnitArray,\n outflowUnitArray\n ) = IRebalancingSetToken(_rebalancingSetToken).placeBid(executionQuantity);\n\n // Retrieve tokens from bidder and deposit in vault for rebalancing set token\n coreInstance.batchDepositModule(\n msg.sender,\n _rebalancingSetToken,\n tokenArray,\n inflowUnitArray\n );\n\n // Withdraw tokens from Rebalancing Set Token vault account to bidder\n coreInstance.batchWithdrawModule(\n _rebalancingSetToken,\n msg.sender,\n tokenArray,\n outflowUnitArray\n );\n\n // Log bid placed event\n emit BidPlaced(\n _rebalancingSetToken,\n msg.sender,\n executionQuantity,\n tokenArray,\n inflowUnitArray,\n outflowUnitArray\n );\n }\n\n /**\n * If a Rebalancing Set Token Rebalance has failed (it includes paused token or exceeds gas limits)\n * and been put in Drawdown state, user's can withdraw their portion of the components collateralizing\n * the Rebalancing Set Token. This burns the user's portion of the Rebalancing Set Token.\n *\n * @param _rebalancingSetToken Address of the rebalancing token to withdraw from\n */\n function redeemFromFailedRebalance(\n address _rebalancingSetToken\n )\n external\n nonReentrant\n {\n // Create Rebalancing Set Token instance\n IRebalancingSetToken rebalancingSetToken = IRebalancingSetToken(_rebalancingSetToken);\n\n // Make sure the rebalancingSetToken is tracked by Core\n require(\n coreInstance.validSets(_rebalancingSetToken),\n \"RebalanceAuctionModule.redeemFromFailedRebalance: Invalid or disabled SetToken address\"\n );\n\n // Get getFailedAuctionWithdrawComponents from RebalancingSetToken\n address[] memory withdrawComponents = rebalancingSetToken.getFailedAuctionWithdrawComponents();\n\n // Get Rebalancing Set Token's total supply\n uint256 setTotalSupply = rebalancingSetToken.totalSupply();\n\n // Get caller's balance\n uint256 callerBalance = rebalancingSetToken.balanceOf(msg.sender);\n\n // Get RebalancingSetToken component amounts and calculate caller's portion of each token\n uint256 transferArrayLength = withdrawComponents.length;\n uint256[] memory componentTransferAmount = new uint256[](transferArrayLength);\n for (uint256 i = 0; i < transferArrayLength; i++) {\n uint256 tokenCollateralAmount = vaultInstance.getOwnerBalance(\n withdrawComponents[i],\n _rebalancingSetToken\n );\n componentTransferAmount[i] = tokenCollateralAmount.mul(callerBalance).div(setTotalSupply);\n }\n\n // Burn caller's balance of Rebalancing Set Token\n rebalancingSetToken.burn(\n msg.sender,\n callerBalance\n );\n\n // Transfer token amounts to caller in Vault from Rebalancing Set Token\n coreInstance.batchTransferBalanceModule(\n withdrawComponents,\n _rebalancingSetToken,\n msg.sender,\n componentTransferAmount\n );\n }\n\n /* ============ Internal Functions ============ */\n\n /**\n * Get execution quantity in event bid quantity exceeds remainingCurrentSets\n *\n * @param _rebalancingSetToken Address of the rebalancing token being bid on\n * @param _quantity Number of currentSets to rebalance\n * @param _allowPartialFill Set to true if want to partially fill bid when quantity\n is greater than currentRemainingSets\n * @return executionQuantity Array of token addresses invovled in rebalancing\n */\n function calculateExecutionQuantity(\n address _rebalancingSetToken,\n uint256 _quantity,\n bool _allowPartialFill\n )\n internal\n view\n returns (uint256)\n {\n // Make sure the rebalancingSetToken is tracked by Core\n require(\n coreInstance.validSets(_rebalancingSetToken),\n \"RebalanceAuctionModule.bid: Invalid or disabled SetToken address\"\n );\n\n // Receive bidding parameters of current auction\n uint256[] memory biddingParameters = IRebalancingSetToken(_rebalancingSetToken).getBiddingParameters();\n uint256 minimumBid = biddingParameters[0];\n uint256 remainingCurrentSets = biddingParameters[1];\n\n if (_allowPartialFill && _quantity > remainingCurrentSets) { \n // If quantity is greater than remainingCurrentSets round amount to nearest multiple of\n // minimumBid that is less than remainingCurrentSets\n uint256 executionQuantity = remainingCurrentSets.div(minimumBid).mul(minimumBid);\n return executionQuantity;\n } else {\n return _quantity;\n }\n }\n}\n"
},
{
"path": "contracts/core/modules/RebalancingSetCTokenExchangeIssuanceModule.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { CTokenWhiteListed } from \"./lib/CTokenWhiteListed.sol\";\nimport { ExchangeIssuanceLibrary } from \"./lib/ExchangeIssuanceLibrary.sol\";\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\nimport { IAddressToAddressWhiteList } from \"../interfaces/IAddressToAddressWhiteList.sol\";\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IExchangeIssuanceModule } from \"../interfaces/IExchangeIssuanceModule.sol\";\nimport { IRebalancingSetToken } from \"../interfaces/IRebalancingSetToken.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { ITransferProxy } from \"../interfaces/ITransferProxy.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\nimport { IWETH } from \"../../lib/IWETH.sol\";\nimport { RebalancingSetExchangeIssuanceModule } from \"./RebalancingSetExchangeIssuanceModule.sol\";\n\n\n/**\n * @title RebalancingSetCTokenExchangeIssuanceModule\n * @author Set Protocol\n *\n * The RebalancingSetCTokenExchangeIssuanceModule supplementary smart contract allows a user to issue and redeem a Rebalancing Set\n * using a payment token or receiving a receive token atomically in a single transaction using liquidity from\n * decentralized exchanges. If cToken, the module handles redeeming cToken during redemption process\n * Note: This module is not compatible with Compound Ether (cETH).\n */\ncontract RebalancingSetCTokenExchangeIssuanceModule is\n RebalancingSetExchangeIssuanceModule,\n CTokenWhiteListed\n{\n using SafeMath for uint256;\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for RebalancingSetCTokenExchangeIssuanceModule\n *\n * @param _core The address of Core\n * @param _transferProxy The address of the TransferProxy\n * @param _exchangeIssuanceModule The address of ExchangeIssuanceModule\n * @param _wrappedEther The address of wrapped ether\n * @param _vault The address of Vault\n */\n constructor(\n ICore _core,\n ITransferProxy _transferProxy,\n IExchangeIssuanceModule _exchangeIssuanceModule,\n IWETH _wrappedEther,\n IVault _vault,\n IAddressToAddressWhiteList _cTokenWhiteList\n )\n public\n RebalancingSetExchangeIssuanceModule(\n _core,\n _transferProxy,\n _exchangeIssuanceModule,\n _wrappedEther,\n _vault\n )\n CTokenWhiteListed(\n address(_transferProxy),\n _cTokenWhiteList\n )\n {}\n\n /* ============ Private Functions ============ */\n\n /**\n * Withdraw any base Set components to the user in the vault owned by the contract. If component is a \n * supported cToken, calculate underlying quantity in vault and return to the caller. Note: there may be \n * excess cTokens so we flush underlying in addition to the cToken component. \n `*\n * This function overrides returnExcessComponentsFromVault from TokenFlush\n *\n * @param _baseSetToken Instance of the Base SetToken\n * @param _returnAddress The address to send excess tokens to\n */\n function returnExcessComponentsFromVault(\n ISetToken _baseSetToken,\n address _returnAddress\n )\n internal\n {\n // Return base Set components\n address[] memory baseSetComponents = _baseSetToken.getComponents();\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n address currentComponentAddress = baseSetComponents[i];\n\n address underlyingAddress = cTokenWhiteList.whitelist(currentComponentAddress);\n uint256 vaultQuantity = vaultInstance.getOwnerBalance(currentComponentAddress, address(this));\n\n // Check if component is a cToken and quantity is greater than 0\n if (underlyingAddress != address(0)) {\n // Get balance of underlying in vault\n uint256 underlyingVaultQuantity = vaultInstance.getOwnerBalance(\n underlyingAddress,\n address(this)\n );\n\n // Check if underlying token quantity greater than 0, and return underlying from vault\n if (underlyingVaultQuantity > 0) {\n coreInstance.withdrawModule(\n address(this),\n _returnAddress,\n underlyingAddress,\n underlyingVaultQuantity\n );\n }\n }\n\n // Check if base Set components in vault is greater than 0.\n if (vaultQuantity > 0) {\n // Return the unexchanged components (including cToken components) from vault to the caller\n coreInstance.withdrawModule(\n address(this),\n _returnAddress,\n currentComponentAddress,\n vaultQuantity\n );\n }\n } \n }\n\n /**\n * Withdraw any base Set components to the user from the contract. If component is a supported cToken,\n * calculate underlying quantity and return to the caller\n *\n * @param _baseSetToken Instance of the Base SetToken\n * @param _returnAddress The address to send excess tokens to\n */\n function returnExcessComponentsFromContract(\n ISetToken _baseSetToken,\n address _returnAddress\n )\n internal\n {\n // Return base Set components\n address[] memory baseSetComponents = _baseSetToken.getComponents();\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n address currentComponentAddress = baseSetComponents[i];\n uint256 currentComponentQuantity = ERC20Wrapper.balanceOf(baseSetComponents[i], address(this));\n\n address underlyingAddress = cTokenWhiteList.whitelist(currentComponentAddress);\n if (underlyingAddress != address(0)) {\n // Get balance of underlying\n uint256 underlyingQuantity = ERC20Wrapper.balanceOf(\n underlyingAddress,\n address(this)\n );\n\n // Check if underlying token quantity greater than 0\n if (underlyingQuantity > 0) {\n ERC20Wrapper.transfer(\n underlyingAddress,\n _returnAddress,\n underlyingQuantity\n ); \n }\n } else {\n // Check if non cToken component quantity is greater than 0\n if (currentComponentQuantity > 0) {\n // Return the unexchanged non cToken components to the caller\n ERC20Wrapper.transfer(\n currentComponentAddress,\n _returnAddress,\n currentComponentQuantity\n ); \n }\n }\n } \n }\n\n\n}"
},
{
"path": "contracts/core/modules/RebalancingSetCTokenIssuanceModule.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\nimport { CompoundUtils } from \"set-protocol-contract-utils/contracts/lib/CompoundUtils.sol\";\n\nimport { CTokenWhiteListed } from \"./lib/CTokenWhiteListed.sol\";\nimport { ICToken } from \"../interfaces/ICToken.sol\";\nimport { IRebalancingSetToken } from \"../interfaces/IRebalancingSetToken.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { IWETH } from \"../../lib/IWETH.sol\";\nimport { IAddressToAddressWhiteList } from \"../interfaces/IAddressToAddressWhiteList.sol\";\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\nimport { RebalancingSetIssuanceModule } from \"./RebalancingSetIssuanceModule.sol\";\n\n\n/**\n * @title RebalancingSetCTokenIssuanceModule\n * @author Set Protocol\n *\n * A module that includes functions for issuing / redeeming rebalancing SetToken from its base components, cToken\n * underlying components, and Ether. Note: This module is not compatible with Compound Ether (cETH).\n */\ncontract RebalancingSetCTokenIssuanceModule is\n RebalancingSetIssuanceModule,\n CTokenWhiteListed\n{\n using SafeMath for uint256;\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for RebalancingSetCTokenIssuanceModule\n *\n * @param _core The address of Core\n * @param _vault The address of Vault\n * @param _transferProxy The address of TransferProxy\n * @param _weth Instance of Wrapped Ether\n * @param _cTokenWhiteList Instance of whitelisted cTokens to underlying addresses\n */\n constructor(\n address _core,\n address _vault,\n address _transferProxy,\n IWETH _weth,\n IAddressToAddressWhiteList _cTokenWhiteList\n )\n public\n RebalancingSetIssuanceModule(\n _core,\n _vault,\n _transferProxy,\n _weth\n )\n CTokenWhiteListed(\n _transferProxy,\n _cTokenWhiteList\n )\n {}\n\n /* ============ External Functions ============ */\n\n /**\n * Issue a rebalancing SetToken using the base components of the base SetToken. If the base component is a supported\n * cToken, retrieve the underlying from the user and mint the cToken. The base SetToken is then issued\n * into the rebalancing SetToken. The base SetToken quantity issued is calculated by taking the rebalancing SetToken's quantity,\n * unit shares, and natural unit. If the calculated quantity is not a multiple of the natural unit of the base SetToken,\n * the quantity is rounded up to the base SetToken natural unit.\n * NOTE: Potential to receive more baseSet than expected if someone transfers some to this module.\n * Be careful with balance checks.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to issue\n * @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user\n * or left in the vault\n */\n function issueRebalancingSet(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n external\n nonReentrant\n {\n // Get baseSet address and quantity required for issuance of Rebalancing Set\n (\n address baseSetAddress,\n uint256 requiredBaseSetQuantity\n ) = getBaseSetAddressAndQuantity(_rebalancingSetAddress, _rebalancingSetQuantity);\n\n // Deposit components, mint cTokens, issue base and rebalancing Set tokens and return excess base to sender\n // Set false because function is not wrapping Ether\n issueRebalancingSetInternal(\n _rebalancingSetAddress,\n _rebalancingSetQuantity,\n baseSetAddress,\n requiredBaseSetQuantity,\n _keepChangeInVault,\n false\n );\n }\n\n /**\n * Issue a rebalancing SetToken using the base components and ether of the base SetToken. If the base component\n * is a supported cToken, retrieve the underlying from the user and mint the cToken. The ether is wrapped\n * into wrapped Ether and utilized in issuance.\n * The base SetToken is then issued and reissued into the rebalancing SetToken. Read more about base SetToken quantity\n * in the issueRebalancingSet function.\n * NOTE: Potential to receive more baseSet and ether dust than expected if someone transfers some to this module.\n * Be careful with balance checks.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to issue\n * @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user\n * or left in the vault\n */\n function issueRebalancingSetWrappingEther(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n external\n payable\n nonReentrant\n {\n // Get baseSet address and quantity required for issuance of Rebalancing Set\n (\n address baseSetAddress,\n uint256 requiredBaseSetQuantity\n ) = getBaseSetAddressAndQuantity(_rebalancingSetAddress, _rebalancingSetQuantity);\n\n // Validate that WETH is a component of baseSet\n validateWETHIsAComponentOfSet(baseSetAddress, address(weth));\n\n // Deposit components, mint cTokens, issue base and rebalancing Set tokens and return excess base to sender\n // Set true because function is wrapping Ether\n issueRebalancingSetInternal(\n _rebalancingSetAddress,\n _rebalancingSetQuantity,\n baseSetAddress,\n requiredBaseSetQuantity,\n _keepChangeInVault,\n true\n );\n\n // Any eth that is not wrapped is sent back to the user\n // Only the amount required for the base SetToken issuance is wrapped.\n uint256 leftoverEth = address(this).balance;\n if (leftoverEth > 0) {\n msg.sender.transfer(leftoverEth);\n }\n }\n\n /**\n * Redeems a rebalancing SetToken into the base components of the base SetToken. If a supported cToken, then base components\n * are redeemed for the underlying and sent back to user.\n * NOTE: Potential to receive more baseSet than expected if someone transfers some to this module.\n * Be careful with balance checks.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to redeem\n * @param _rebalancingSetQuantity The Quantity of the rebalancing SetToken to redeem\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user\n * or left in the vault\n */\n function redeemRebalancingSet(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n external\n nonReentrant\n {\n // Get base Set address\n address baseSetAddress = IRebalancingSetToken(_rebalancingSetAddress).currentSet();\n\n // Redeem into base Set, redeem into components, redeem cTokens into underlying, and transfer tokens and excess to sender\n // Set false because we are not unwrapping Ether\n redeemRebalancingSetInternal(\n _rebalancingSetAddress,\n _rebalancingSetQuantity,\n baseSetAddress,\n _keepChangeInVault,\n false\n );\n }\n\n /**\n * Redeems a rebalancing SetToken into the base components of the base SetToken. If a supported cToken, then base components\n * are redeemed for the underlying and sent back to user. Unwraps wrapped ether and sends eth to the user.\n * If no wrapped ether in Set then will REVERT.\n * NOTE: Potential to receive more baseSet and ether dust than expected if someone transfers some to this module.\n * Be careful with balance checks.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to redeem\n * @param _rebalancingSetQuantity The Quantity of the rebalancing SetToken to redeem\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user\n * or left in the vault\n */\n function redeemRebalancingSetUnwrappingEther(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n external\n nonReentrant\n {\n // Get base Set address\n address baseSetAddress = IRebalancingSetToken(_rebalancingSetAddress).currentSet();\n \n // Validate that WETH is a component of baseSet\n validateWETHIsAComponentOfSet(baseSetAddress, address(weth));\n\n // Redeem into base Set, redeem into components, redeem cTokens into underlying, and transfer tokens and excess to sender\n // Set true because we are unwrapping Ether\n redeemRebalancingSetInternal(\n _rebalancingSetAddress,\n _rebalancingSetQuantity,\n baseSetAddress,\n _keepChangeInVault,\n true\n );\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Issue a rebalancing SetToken using the base components of the base SetToken. If the base component\n * is a supported cToken, retrieve the underlying from the user and mint the cToken. If wrapEth is true, ether is wrapped\n * into wrapped Ether and utilized in issuance. The base SetToken is then issued\n * into the rebalancing SetToken. The base SetToken quantity issued is calculated by taking the rebalancing SetToken's quantity,\n * unit shares, and natural unit. If the calculated quantity is not a multiple of the natural unit of the base SetToken,\n * the quantity is rounded up to the base SetToken natural unit.\n *\n * @param _rebalancingSetAddress Address of the rebalancing Set to issue\n * @param _rebalancingSetQuantity Quantity of the rebalancing Set\n * @param _baseSetAddress Address of the base Set to issue\n * @param _requiredBaseSetQuantity Quantity of the base Set\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user\n * or left in the vault\n * @param _wrapEth Boolean indicating whether to wrap Eth\n */\n function issueRebalancingSetInternal(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n address _baseSetAddress,\n uint256 _requiredBaseSetQuantity,\n bool _keepChangeInVault,\n bool _wrapEth\n )\n private\n {\n // Deposit components and mint cTokens. Set true because we are wrapping Ether\n // If wrapEth is true, the required ether is wrapped and approved to the transferProxy\n depositComponentsHandleCTokensAndEth(\n _baseSetAddress,\n _requiredBaseSetQuantity,\n _wrapEth\n );\n\n // Issue base SetToken to this contract, with the base SetToken held in the Vault\n coreInstance.issueInVault(\n _baseSetAddress,\n _requiredBaseSetQuantity\n );\n\n // Note: Don't need to set allowance of the base SetToken as the base SetToken is already in the vault\n\n // Issue rebalancing SetToken to the sender and return any excess base to sender\n issueRebalancingSetAndReturnExcessBase(\n _rebalancingSetAddress,\n _baseSetAddress,\n _rebalancingSetQuantity,\n _keepChangeInVault\n );\n }\n\n /**\n * Redeems a rebalancing SetToken into the base components of the base SetToken. If a supported cToken, then base components\n * are redeemed for the underlying and sent back to user. If wrapEth is true, unwraps wrapped ether and sends eth to the user.\n *\n * @param _rebalancingSetAddress Address of the rebalancing Set to redeem\n * @param _rebalancingSetQuantity Quantity of the rebalancing Set\n * @param _baseSetAddress Address of the base Set to redeem\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user\n * or left in the vault\n * @param _unwrapEth Boolean indicating whether to unwrap Eth\n */\n function redeemRebalancingSetInternal(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n address _baseSetAddress,\n bool _keepChangeInVault,\n bool _unwrapEth\n )\n private\n {\n // Validate the rebalancing SetToken is valid and the quantity is a multiple of the natural unit\n validateRebalancingSetIssuance(_rebalancingSetAddress, _rebalancingSetQuantity);\n\n // Redeem RB Set to the vault attributed to this contract\n coreInstance.redeemModule(\n msg.sender,\n address(this),\n _rebalancingSetAddress,\n _rebalancingSetQuantity\n );\n\n // Calculate the base SetToken Redeem quantity\n uint256 baseSetRedeemQuantity = getBaseSetRedeemQuantity(_baseSetAddress);\n\n // Redeem the base SetToken and keep components in the vault\n coreInstance.redeemInVault(\n _baseSetAddress,\n baseSetRedeemQuantity\n );\n\n // Withdraw components and redeem cTokens. Transfer tokens to sender.\n // If unwrapEth is true, the required ether is unwrapped\n withdrawComponentsHandleCTokensAndEth(_baseSetAddress, _unwrapEth);\n\n // Transfer any change of the base SetToken to the end user\n returnExcessBaseSet(_baseSetAddress, transferProxy, _keepChangeInVault);\n\n // Log RebalancingSetRedeem\n emit LogRebalancingSetRedeem(\n _rebalancingSetAddress,\n msg.sender,\n _rebalancingSetQuantity\n );\n }\n\n /**\n * During issuance, deposit the required quantity of base SetToken, handle cToken minting, wrap Ether, and deposit components\n * (excluding Ether, which is deposited during issuance) to the Vault in the name of the module.\n *\n * @param _baseSetAddress Address of the base SetToken token\n * @param _baseSetQuantity The Quantity of the base SetToken token to issue\n * @param _wrapEth Boolean indicating whether to wrap Eth\n */\n function depositComponentsHandleCTokensAndEth(\n address _baseSetAddress,\n uint256 _baseSetQuantity,\n bool _wrapEth\n )\n private\n {\n ISetToken baseSet = ISetToken(_baseSetAddress);\n\n address[] memory baseSetComponents = baseSet.getComponents();\n uint256[] memory baseSetUnits = baseSet.getUnits();\n uint256 baseSetNaturalUnit = baseSet.naturalUnit();\n\n // Calculate the number of natural units required and round down to nearest natural unit\n uint256 quantityOfNaturalUnits = _baseSetQuantity.div(baseSetNaturalUnit); \n\n // Loop through the base SetToken components and deposit components\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n address currentComponentAddress = baseSetComponents[i];\n uint256 currentUnit = baseSetUnits[i];\n\n // Calculate required component quantity\n uint256 currentComponentQuantity = quantityOfNaturalUnits.mul(currentUnit);\n\n // If cToken, calculate required underlying tokens and transfer to module\n address underlyingAddress = cTokenWhiteList.whitelist(currentComponentAddress);\n if (underlyingAddress != address(0)) {\n // Deposit underlying components and mint cToken\n depositAndMintCToken(\n ICToken(currentComponentAddress),\n currentComponentQuantity,\n underlyingAddress\n );\n } else if (_wrapEth && currentComponentAddress == address(weth)) {\n // If address is weth, deposit weth and transfer eth\n // Expect the ether included exceeds the required Weth quantity\n require(\n msg.value >= currentComponentQuantity,\n \"RebalancingSetCTokenIssuanceModule.depositComponentsHandleCTokensAndEth: Not enough ether included for base SetToken\"\n );\n\n // Wrap the required ether quantity\n // NOTE: Weth is wrapped but does not get deposited to vault. When issuing, WETH is pulled from contract to vault\n weth.deposit.value(currentComponentQuantity)();\n\n // Ensure weth allowance\n ERC20Wrapper.ensureAllowance(\n address(weth),\n address(this),\n transferProxy,\n currentComponentQuantity\n );\n } else {\n // Deposit components to the vault in the name of the contract\n coreInstance.depositModule(\n msg.sender,\n address(this),\n currentComponentAddress,\n currentComponentQuantity\n );\n }\n }\n }\n\n /**\n * This function deposits the underlying components into the module and mints cToken\n *\n * @param _cToken Instance of the cToken to mint\n * @param _cTokenQuantity Quantity of the cToken required\n * @param _underlyingAddress Address of the underlying component\n */\n function depositAndMintCToken(\n ICToken _cToken,\n uint256 _cTokenQuantity,\n address _underlyingAddress\n )\n private\n {\n // Calculate required amount of underlying. Calculated as cToken quantity * exchangeRate / 10 ** 18.\n uint256 exchangeRate = _cToken.exchangeRateCurrent();\n uint256 underlyingQuantity = CompoundUtils.convertCTokenToUnderlying(_cTokenQuantity, exchangeRate);\n\n // Transfer components to this module\n coreInstance.transferModule(\n _underlyingAddress,\n underlyingQuantity,\n msg.sender,\n address(this)\n );\n\n // Ensure allowance for underlying token to cToken contract. This is for cases if we add a new cToken to the whitelist\n ERC20Wrapper.ensureAllowance(\n _underlyingAddress,\n address(this),\n address(_cToken),\n underlyingQuantity\n );\n\n // Mint cToken using underlying\n uint256 mintResponse = _cToken.mint(underlyingQuantity);\n require(\n mintResponse == 0,\n \"CTokenExchangeIssuanceModule.exchangeIssue: Error minting cToken\"\n );\n\n // Get balance of cTokens minted in the contract\n uint256 cTokenQuantity = ERC20Wrapper.balanceOf(\n address(_cToken),\n address(this)\n );\n\n // Ensure allowance for cToken to transferProxy. This is for cases if we add a new cToken to the whitelist\n ERC20Wrapper.ensureAllowance(\n address(_cToken),\n address(this),\n transferProxy,\n cTokenQuantity\n );\n\n // Deposit transformed cTokens to vault (owned by this contract)\n coreInstance.depositModule(\n address(this),\n address(this),\n address(_cToken),\n cTokenQuantity\n );\n }\n\n /**\n * During redemption, withdraw the required quantity of base SetToken, and withdraw\n * components to the sender. If _unwrapEth is true, then unwrap weth into Ether\n *\n * @param _baseSetAddress Address of the base SetToken\n * @param _unwrapEth Boolean indicating whether to withdraw to Eth\n */\n function withdrawComponentsHandleCTokensAndEth(\n address _baseSetAddress,\n bool _unwrapEth\n )\n private\n {\n address[] memory baseSetComponents = ISetToken(_baseSetAddress).getComponents();\n\n // Loop through the base SetToken components.\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n address currentComponentAddress = baseSetComponents[i];\n uint256 currentComponentQuantity = vaultInstance.getOwnerBalance(\n currentComponentAddress,\n address(this)\n );\n\n // If cToken, calculate required underlying tokens and transfer to module\n address underlyingAddress = cTokenWhiteList.whitelist(currentComponentAddress);\n if (underlyingAddress != address(0)) {\n // Redeem underlying components send to user\n redeemCTokenAndWithdraw(\n ICToken(currentComponentAddress),\n currentComponentQuantity,\n underlyingAddress\n );\n }\n else if (_unwrapEth && currentComponentAddress == address(weth)) {\n // If address is weth, withdraw weth and transfer eth to sender\n // Transfer the wrapped ether to this address from the Vault\n coreInstance.withdrawModule(\n address(this),\n address(this),\n address(weth),\n currentComponentQuantity\n );\n\n // Unwrap wrapped ether\n weth.withdraw(currentComponentQuantity);\n\n // Transfer to recipient\n msg.sender.transfer(currentComponentQuantity);\n } else {\n // Withdraw component from the Vault and send to the user\n coreInstance.withdrawModule(\n address(this),\n msg.sender,\n currentComponentAddress,\n currentComponentQuantity\n );\n }\n }\n }\n\n /**\n * This function redeems the cToken in the module and withdraws the underlying component to the user\n *\n * @param _cToken Instance of the cToken to redeem\n * @param _cTokenQuantity Quantity of the cToken to redeem\n * @param _underlyingAddress Address of the underlying component\n */\n function redeemCTokenAndWithdraw(\n ICToken _cToken,\n uint256 _cTokenQuantity,\n address _underlyingAddress\n )\n private\n {\n // Calculate required amount of underlying. Calculated as cToken quantity * exchangeRate / 10 ** 18.\n uint256 exchangeRate = _cToken.exchangeRateCurrent();\n uint256 underlyingQuantity = CompoundUtils.convertCTokenToUnderlying(_cTokenQuantity, exchangeRate);\n\n // Transfer the cToken to this address from the Vault\n coreInstance.withdrawModule(\n address(this),\n address(this),\n address(_cToken),\n _cTokenQuantity\n );\n\n // Redeem cToken to underlying\n uint256 redeemResponse = _cToken.redeem(_cTokenQuantity);\n require(\n redeemResponse == 0,\n \"CTokenExchangeIssuanceModule.exchangeRedeem: Error redeeming cToken\"\n );\n\n // Get balance of underlying after cToken redemption and override\n underlyingQuantity = ERC20Wrapper.balanceOf(\n _underlyingAddress,\n address(this)\n );\n\n // Transfer underlying component from the module to the user\n coreInstance.transferModule(\n _underlyingAddress,\n underlyingQuantity,\n address(this),\n msg.sender\n );\n }\n}"
},
{
"path": "contracts/core/modules/RebalancingSetExchangeIssuanceModule.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ExchangeIssuanceLibrary } from \"./lib/ExchangeIssuanceLibrary.sol\";\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IExchangeIssuanceModule } from \"../interfaces/IExchangeIssuanceModule.sol\";\nimport { IRebalancingSetToken } from \"../interfaces/IRebalancingSetToken.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { ITransferProxy } from \"../interfaces/ITransferProxy.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\nimport { IWETH } from \"../../lib/IWETH.sol\";\nimport { ModuleCoreStateV2 } from \"./lib/ModuleCoreStateV2.sol\";\nimport { TokenFlush } from \"./lib/TokenFlush.sol\";\n\n\n/**\n * @title RebalancingSetExchangeIssuanceModule\n * @author Set Protocol\n *\n * The RebalancingSetExchangeIssuanceModule supplementary smart contract allows a user to issue and redeem a Rebalancing Set\n * using a payment token or receiving a receive token atomically in a single transaction using liquidity from\n * decentralized exchanges.\n */\ncontract RebalancingSetExchangeIssuanceModule is\n ModuleCoreStateV2,\n TokenFlush,\n ReentrancyGuard\n{\n using SafeMath for uint256;\n\n /* ============ State Variables ============ */\n\n // Address and instance of ExchangeIssuance Module contract\n IExchangeIssuanceModule public exchangeIssuanceModuleInstance;\n\n // Address and instance of Wrapped Ether contract\n IWETH public wethInstance;\n\n /* ============ Events ============ */\n\n event LogPayableExchangeIssue(\n address indexed rebalancingSetAddress,\n address indexed callerAddress,\n address paymentTokenAddress,\n uint256 rebalancingSetQuantity,\n uint256 paymentTokenReturned\n );\n\n event LogPayableExchangeRedeem(\n address indexed rebalancingSetAddress,\n address indexed callerAddress,\n address outputTokenAddress,\n uint256 rebalancingSetQuantity,\n uint256 outputTokenQuantity\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for RebalancingSetExchangeIssuanceModule\n *\n * @param _core The address of Core\n * @param _transferProxy The address of the TransferProxy\n * @param _exchangeIssuanceModule The address of ExchangeIssuanceModule\n * @param _wrappedEther The address of wrapped ether\n * @param _vault The address of Vault\n */\n constructor(\n ICore _core,\n ITransferProxy _transferProxy,\n IExchangeIssuanceModule _exchangeIssuanceModule,\n IWETH _wrappedEther,\n IVault _vault\n )\n public\n ModuleCoreStateV2(\n _core,\n _vault,\n _transferProxy\n )\n {\n // Commit the instance of ExchangeIssuanceModule to state variables\n exchangeIssuanceModuleInstance = _exchangeIssuanceModule;\n\n // Commit the address and instance of Wrapped Ether to state variables\n wethInstance = _wrappedEther;\n\n // Add approvals of Wrapped Ether to the Transfer Proxy\n ERC20Wrapper.approve(\n address(_wrappedEther),\n address(_transferProxy),\n CommonMath.maxUInt256()\n );\n }\n\n /**\n * Fallback function. Disallows ether to be sent to this contract without data except when\n * unwrapping WETH.\n */\n function ()\n external\n payable\n {\n require(\n msg.sender == address(wethInstance),\n \"RebalancingSetExchangeIssuanceModule.fallback: Cannot receive ETH directly unless unwrapping WETH\"\n );\n }\n\n /* ============ Public Functions ============ */\n\n /**\n * Issue a Rebalancing Set using Wrapped Ether to acquire the base components of the Base Set.\n * The Base Set is then issued using ExchangeIssue and reissued into the Rebalancing Set.\n * All remaining tokens / change are flushed and returned to the user.\n *\n * @param _rebalancingSetAddress Address of the rebalancing Set to issue\n * @param _rebalancingSetQuantity Quantity of the rebalancing Set\n * @param _exchangeIssuanceParams Struct containing data around the base Set issuance\n * @param _orderData Bytecode encoding exchange data for acquiring base set components\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user\n * or left in the vault\n */\n function issueRebalancingSetWithEther(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData,\n bool _keepChangeInVault\n )\n public\n payable\n nonReentrant\n {\n // Wrap all Ether; Wrapped Ether could be a component of the Set being issued.\n wethInstance.deposit.value(msg.value)();\n\n // Perform exchange transactions, mint the base SetToken, and issue the Rebalancing Set to the sender\n issueRebalancingSetInternal(\n _rebalancingSetAddress,\n _rebalancingSetQuantity,\n address(wethInstance),\n msg.value,\n _exchangeIssuanceParams,\n _orderData,\n _keepChangeInVault\n );\n\n // unwrap any leftover WETH and transfer to sender\n uint256 leftoverWeth = ERC20Wrapper.balanceOf(address(wethInstance), address(this));\n if (leftoverWeth > 0) {\n // Withdraw wrapped Ether\n wethInstance.withdraw(leftoverWeth);\n\n // Transfer ether to user\n msg.sender.transfer(leftoverWeth);\n }\n\n emit LogPayableExchangeIssue(\n _rebalancingSetAddress,\n msg.sender,\n address(wethInstance),\n _rebalancingSetQuantity,\n leftoverWeth\n );\n }\n\n /**\n * Issue a Rebalancing Set using a specified ERC20 payment token. The payment token is used in ExchangeIssue\n * to acquire the base SetToken components and issue the base SetToken. The base SetToken is then used to\n * issue the Rebalancing SetToken. The payment token can be utilized as a component of the base SetToken.\n * All remaining tokens / change are flushed and returned to the user.\n * Ahead of calling this function, the user must approve their paymentToken to the transferProxy.\n *\n * @param _rebalancingSetAddress Address of the rebalancing Set to issue\n * @param _rebalancingSetQuantity Quantity of the rebalancing Set\n * @param _paymentTokenAddress Address of the ERC20 token to pay with\n * @param _paymentTokenQuantity Quantity of the payment token\n * @param _exchangeIssuanceParams Struct containing data around the base Set issuance\n * @param _orderData Bytecode formatted data with exchange data for acquiring base set components\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user\n * or left in the vault\n */\n function issueRebalancingSetWithERC20(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n address _paymentTokenAddress,\n uint256 _paymentTokenQuantity,\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData,\n bool _keepChangeInVault\n )\n public\n nonReentrant\n {\n // Deposit the erc20 to this contract. The token must be approved the caller to the transferProxy\n coreInstance.transferModule(\n _paymentTokenAddress,\n _paymentTokenQuantity,\n msg.sender,\n address(this)\n );\n\n // Perform exchange transactions, mint the base SetToken, and issue the Rebalancing Set to the sender\n issueRebalancingSetInternal(\n _rebalancingSetAddress,\n _rebalancingSetQuantity,\n _paymentTokenAddress,\n _paymentTokenQuantity,\n _exchangeIssuanceParams,\n _orderData,\n _keepChangeInVault\n );\n\n // Send back any unused payment token\n uint256 leftoverPaymentTokenQuantity = ERC20Wrapper.balanceOf(_paymentTokenAddress, address(this));\n if (leftoverPaymentTokenQuantity > 0) {\n ERC20Wrapper.transfer(\n _paymentTokenAddress,\n msg.sender,\n leftoverPaymentTokenQuantity\n );\n }\n\n emit LogPayableExchangeIssue(\n _rebalancingSetAddress,\n msg.sender,\n _paymentTokenAddress,\n _rebalancingSetQuantity,\n leftoverPaymentTokenQuantity\n );\n }\n\n /**\n * Redeems a Rebalancing Set into ether. The Rebalancing Set is redeemed into the Base Set, and\n * Base Set components are traded for WETH. The WETH is then withdrawn into ETH and the ETH sent to the caller.\n *\n * @param _rebalancingSetAddress Address of the rebalancing Set\n * @param _rebalancingSetQuantity Quantity of rebalancing Set to redeem\n * @param _exchangeIssuanceParams Struct containing data around the base Set issuance\n * @param _orderData Bytecode encoding exchange data for disposing base set components\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user\n * or left in the vault\n */\n function redeemRebalancingSetIntoEther(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData,\n bool _keepChangeInVault\n )\n public\n nonReentrant\n {\n // Redeems the rebalancing Set into the base SetToken, redeems the base SetToken into its components,\n // and exchanges the components into wrapped ether to this contract.\n redeemRebalancingSetIntoComponentsInternal(\n _rebalancingSetAddress,\n _rebalancingSetQuantity,\n address(wethInstance),\n _exchangeIssuanceParams,\n _orderData\n );\n\n // In the event that exchangeIssue returns more receiveTokens or wrappedEth than\n // specified in receiveToken quantity, those tokens are also retrieved into this contract.\n // We also call this ahead of returnRedemptionChange to allow the unwrapping of the wrappedEther\n uint256 wethQuantityInVault = vaultInstance.getOwnerBalance(address(wethInstance), address(this));\n if (wethQuantityInVault > 0) {\n coreInstance.withdrawModule(\n address(this),\n address(this),\n address(wethInstance),\n wethQuantityInVault\n );\n }\n\n // Unwrap wrapped Ether and transfer Eth to user\n uint256 wethBalance = ERC20Wrapper.balanceOf(address(wethInstance), address(this));\n if (wethBalance > 0) {\n wethInstance.withdraw(wethBalance);\n msg.sender.transfer(wethBalance);\n }\n\n address baseSetAddress = _exchangeIssuanceParams.setAddress;\n\n // Send excess base Set to the user\n returnExcessBaseSetFromContract(\n baseSetAddress,\n msg.sender,\n _keepChangeInVault\n );\n\n // Return non-exchanged components to the user\n returnExcessComponentsFromContract(ISetToken(baseSetAddress), msg.sender);\n\n emit LogPayableExchangeRedeem(\n _rebalancingSetAddress,\n msg.sender,\n address(wethInstance),\n _rebalancingSetQuantity,\n wethBalance\n );\n }\n\n /**\n * Redeems a Rebalancing Set into a specified ERC20 token. The Rebalancing Set is redeemed into the Base Set, and\n * Base Set components are traded for the ERC20 and sent to the caller.\n *\n * @param _rebalancingSetAddress Address of the rebalancing Set\n * @param _rebalancingSetQuantity Quantity of rebalancing Set to redeem\n * @param _outputTokenAddress Address of the resulting ERC20 token sent to the user\n * @param _exchangeIssuanceParams Struct containing data around the base Set issuance\n * @param _orderData Bytecode formatted data with exchange data for disposing base set components\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user\n * or left in the vault\n */\n function redeemRebalancingSetIntoERC20(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n address _outputTokenAddress,\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData,\n bool _keepChangeInVault\n )\n public\n nonReentrant\n {\n // Redeems the rebalancing Set into the base SetToken, redeems the base SetToken into its components,\n // and exchanges the components into the receiveToken to this contract.\n redeemRebalancingSetIntoComponentsInternal(\n _rebalancingSetAddress,\n _rebalancingSetQuantity,\n _outputTokenAddress,\n _exchangeIssuanceParams,\n _orderData\n );\n\n // In the event that exchangeIssue returns more outputTokens than\n // specified in receiveToken quantity, those tokens are also retrieved into this contract.\n uint256 outputTokenInVault = vaultInstance.getOwnerBalance(_outputTokenAddress, address(this));\n if (outputTokenInVault > 0) {\n coreInstance.withdrawModule(\n address(this),\n address(this),\n _outputTokenAddress,\n outputTokenInVault\n );\n }\n\n // Transfer outputToken to the caller\n uint256 outputTokenBalance = ERC20Wrapper.balanceOf(_outputTokenAddress, address(this));\n ERC20Wrapper.transfer(\n _outputTokenAddress,\n msg.sender,\n outputTokenBalance\n );\n\n address baseSetAddress = _exchangeIssuanceParams.setAddress;\n\n // Send excess base SetToken to the user\n returnExcessBaseSetFromContract(\n baseSetAddress,\n msg.sender,\n _keepChangeInVault\n );\n\n // Non-exchanged base SetToken components are returned to the user\n returnExcessComponentsFromContract(ISetToken(baseSetAddress), msg.sender);\n\n emit LogPayableExchangeRedeem(\n _rebalancingSetAddress,\n msg.sender,\n _outputTokenAddress,\n _rebalancingSetQuantity,\n outputTokenBalance\n );\n }\n\n\n /* ============ Private Functions ============ */\n\n /**\n * Validate that the issuance parameters and inputs are congruent.\n *\n * @param _transactTokenAddress Address of the sendToken (issue) or receiveToken (redeem)\n * @param _rebalancingSetAddress Address of the rebalancing SetToken\n * @param _rebalancingSetQuantity Quantity of rebalancing SetToken to issue or redeem\n * @param _baseSetAddress Address of base SetToken in ExchangeIssueanceParams\n * @param _transactTokenArray List of addresses of send tokens (during issuance) and\n * receive tokens (during redemption)\n */\n function validateExchangeIssuanceInputs(\n address _transactTokenAddress,\n IRebalancingSetToken _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n address _baseSetAddress,\n address[] memory _transactTokenArray\n )\n private\n view\n {\n // Expect rebalancing SetToken to be valid and enabled SetToken\n require(\n coreInstance.validSets(address(_rebalancingSetAddress)),\n \"RebalancingSetExchangeIssuance.validateExchangeIssuanceInputs: Invalid or disabled SetToken address\"\n );\n\n require(\n _rebalancingSetQuantity > 0,\n \"RebalancingSetExchangeIssuance.validateExchangeIssuanceInputs: Quantity must be > 0\"\n );\n\n // Make sure Issuance quantity is multiple of the rebalancing SetToken natural unit\n require(\n _rebalancingSetQuantity.mod(_rebalancingSetAddress.naturalUnit()) == 0,\n \"RebalancingSetExchangeIssuance.validateExchangeIssuanceInputs: Quantity must be multiple of natural unit\"\n );\n\n // Multiple items are allowed on the transactTokenArray. Specifically, this allows there to be\n // multiple sendToken items that are directed to the various exchangeWrappers.\n // The receiveTokenArray is implicitly limited to a single item, as the exchangeIssuanceModuleInstance\n // checks that the receive tokens do not have duplicates\n for (uint256 i = 0; i < _transactTokenArray.length; i++) {\n // The transact token array tokens must match the transact token.\n require(\n _transactTokenAddress == _transactTokenArray[i],\n \"RebalancingSetExchangeIssuance.validateExchangeIssuanceInputs: Send/Receive token must match transact token\"\n );\n }\n\n // Validate that the base Set address matches the issuanceParams Set Address\n address baseSet = _rebalancingSetAddress.currentSet();\n require(\n baseSet == _baseSetAddress,\n \"RebalancingSetExchangeIssuance.validateExchangeIssuanceInputs: Base Set addresses must match\"\n );\n }\n\n /**\n * Issue a Rebalancing Set using a specified ERC20 payment token. The payment token is used in ExchangeIssue\n * to acquire the base SetToken components and issue the base SetToken. The base SetToken is then used to\n * issue the Rebalancing SetToken. The payment token can be utilized as a component of the base SetToken.\n * All remaining tokens / change are flushed and returned to the user.\n *\n * Note: We do not validate the rebalancing SetToken quantity and the exchangeIssuanceParams base SetToken\n * quantity. Thus there could be extra base SetToken (or change) generated.\n *\n * @param _rebalancingSetAddress Address of the rebalancing Set to issue\n * @param _rebalancingSetQuantity Quantity of the rebalancing Set\n * @param _paymentTokenAddress Address of the ERC20 token to pay with\n * @param _paymentTokenQuantity Quantity of the payment token\n * @param _exchangeIssuanceParams Struct containing data around the base Set issuance\n * @param _orderData Bytecode formatted data with exchange data for acquiring base set components\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user\n * or left in the vault\n */\n function issueRebalancingSetInternal(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n address _paymentTokenAddress,\n uint256 _paymentTokenQuantity,\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData,\n bool _keepChangeInVault\n )\n private\n {\n address baseSetAddress = _exchangeIssuanceParams.setAddress;\n uint256 baseSetIssueQuantity = _exchangeIssuanceParams.quantity;\n\n // Validate parameters\n validateExchangeIssuanceInputs(\n _paymentTokenAddress,\n IRebalancingSetToken(_rebalancingSetAddress),\n _rebalancingSetQuantity,\n baseSetAddress,\n _exchangeIssuanceParams.sendTokens\n );\n\n // Ensure payment token allowance to the TransferProxy\n // Note that the paymentToken may also be used as a component to issue the Set\n // So the paymentTokenQuantity must be used vs. the exchangeIssuanceParams sendToken quantity\n ERC20Wrapper.ensureAllowance(\n _paymentTokenAddress,\n address(this),\n address(transferProxyInstance),\n _paymentTokenQuantity\n );\n\n // Atomically trade paymentToken for base SetToken components and mint the base SetToken\n exchangeIssuanceModuleInstance.exchangeIssue(\n _exchangeIssuanceParams,\n _orderData\n );\n\n // Approve base SetToken to transferProxy for minting rebalancing SetToken\n ERC20Wrapper.ensureAllowance(\n baseSetAddress,\n address(this),\n address(transferProxyInstance),\n baseSetIssueQuantity\n );\n\n // Issue rebalancing SetToken to the caller\n coreInstance.issueTo(\n msg.sender,\n _rebalancingSetAddress,\n _rebalancingSetQuantity\n );\n\n // Send excess base Set held in this contract to the user\n // If keepChangeInVault is true, the baseSetToken is held in the Vault\n // which is a UX improvement\n returnExcessBaseSetFromContract(\n baseSetAddress,\n msg.sender,\n _keepChangeInVault\n );\n\n // Return any extra components acquired during exchangeIssue to the user\n returnExcessComponentsFromVault(ISetToken(baseSetAddress), msg.sender);\n }\n\n /**\n * Redeems a Rebalancing Set into the receiveToken. The Rebalancing Set is redeemed into the Base Set, and\n * Base Set components are traded for the receiveToken located in this contract.\n *\n * Note: We do not validate the rebalancing SetToken quantity and the exchangeIssuanceParams base SetToken\n * quantity. Thus there could be extra base SetToken (or change) generated.\n *\n * @param _rebalancingSetAddress Address of the rebalancing Set\n * @param _rebalancingSetQuantity Quantity of rebalancing Set to redeem\n * @param _receiveTokenAddress Address of the receiveToken\n * @param _exchangeIssuanceParams Struct containing data around the base Set issuance\n * @param _orderData Bytecode formatted data with exchange data for disposing base set components\n */\n function redeemRebalancingSetIntoComponentsInternal(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n address _receiveTokenAddress,\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams,\n bytes memory _orderData\n )\n private\n {\n // Validate Params\n validateExchangeIssuanceInputs(\n _receiveTokenAddress,\n IRebalancingSetToken(_rebalancingSetAddress),\n _rebalancingSetQuantity,\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.receiveTokens\n );\n\n // Redeem rebalancing Set into the base SetToken from the user to this contract in the Vault\n coreInstance.redeemModule(\n msg.sender,\n address(this),\n _rebalancingSetAddress,\n _rebalancingSetQuantity\n );\n\n address baseSetAddress = _exchangeIssuanceParams.setAddress;\n uint256 baseSetVaultQuantity = vaultInstance.getOwnerBalance(baseSetAddress, address(this));\n\n // Withdraw base SetToken from Vault to this contract\n coreInstance.withdrawModule(\n address(this),\n address(this),\n baseSetAddress,\n baseSetVaultQuantity\n );\n\n // Redeem base SetToken into components and perform trades / exchanges\n // into the receiveToken. The receiveTokens are transferred to this contract\n // as well as the remaining non-exchanged components\n exchangeIssuanceModuleInstance.exchangeRedeem(\n _exchangeIssuanceParams,\n _orderData\n );\n }\n}"
},
{
"path": "contracts/core/modules/RebalancingSetIssuanceModule.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { IRebalancingSetToken } from \"../interfaces/IRebalancingSetToken.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { IWETH } from \"../../lib/IWETH.sol\";\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\nimport { ModuleCoreState } from \"./lib/ModuleCoreState.sol\";\nimport { RebalancingSetIssuance } from \"./lib/RebalancingSetIssuance.sol\";\n\n\n/**\n * @title RebalancingSetIssuanceModule\n * @author Set Protocol\n *\n * A module that includes functions for issuing / redeeming rebalancing SetToken to/from its base components and ether.\n */\ncontract RebalancingSetIssuanceModule is\n ModuleCoreState,\n RebalancingSetIssuance,\n ReentrancyGuard\n{\n using SafeMath for uint256;\n\n // Address and instance of TransferProxy contract\n address public transferProxy;\n\n // Address and instance of Wrapped Ether contract\n IWETH public weth;\n\n /* ============ Events ============ */\n\n event LogRebalancingSetIssue(\n address indexed rebalancingSetAddress,\n address indexed callerAddress,\n uint256 rebalancingSetQuantity\n );\n\n event LogRebalancingSetRedeem(\n address indexed rebalancingSetAddress,\n address indexed callerAddress,\n uint256 rebalancingSetQuantity\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for RebalancingSetIssuanceModule\n *\n * @param _core The address of Core\n * @param _vault The address of Vault\n * @param _transferProxy The address of TransferProxy\n * @param _weth The address of Wrapped Ether\n */\n constructor(\n address _core,\n address _vault,\n address _transferProxy,\n IWETH _weth\n )\n public\n ModuleCoreState(\n _core,\n _vault\n )\n {\n // Commit the WETH instance\n weth = _weth;\n\n // Commit the transferProxy instance\n transferProxy = _transferProxy;\n }\n\n /**\n * Fallback function. Disallows ether to be sent to this contract without data except when\n * unwrapping WETH.\n */\n function ()\n external\n payable\n {\n require(\n msg.sender == address(weth),\n \"RebalancingSetIssuanceModule.fallback: Cannot receive ETH directly unless unwrapping WETH\"\n );\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Issue a rebalancing SetToken using the base components of the base SetToken.\n * The base SetToken is then issued into the rebalancing SetToken. The base SetToken quantity issued is calculated\n * by taking the rebalancing SetToken's quantity, unit shares, and natural unit. If the calculated quantity is not\n * a multiple of the natural unit of the base SetToken, the quantity is rounded up to the base SetToken natural unit.\n * NOTE: Potential to receive more baseSet than expected if someone transfers some to this module.\n * Be careful with balance checks.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to issue\n * @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user \n * or left in the vault\n */\n function issueRebalancingSet(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n external\n nonReentrant\n {\n // Get baseSet address and quantity required for issuance of Rebalancing Set\n (\n address baseSetAddress,\n uint256 requiredBaseSetQuantity\n ) = getBaseSetAddressAndQuantity(_rebalancingSetAddress, _rebalancingSetQuantity);\n\n // Issue base SetToken to this contract, held in this contract\n coreInstance.issueModule(\n msg.sender,\n address(this),\n baseSetAddress,\n requiredBaseSetQuantity\n );\n\n // Ensure base SetToken allowance to the transferProxy\n ERC20Wrapper.ensureAllowance(\n baseSetAddress,\n address(this),\n transferProxy,\n requiredBaseSetQuantity\n );\n\n // Issue rebalancing SetToken to the sender and return any excess base to sender\n issueRebalancingSetAndReturnExcessBase(\n _rebalancingSetAddress,\n baseSetAddress,\n _rebalancingSetQuantity,\n _keepChangeInVault\n );\n }\n\n /**\n * Issue a rebalancing SetToken using the base components and ether of the base SetToken. The ether is wrapped \n * into wrapped Ether and utilized in issuance.\n * The base SetToken is then issued and reissued into the rebalancing SetToken. Read more about base SetToken quantity\n * in the issueRebalancingSet function.\n * NOTE: Potential to receive more baseSet and ether dust than expected if someone transfers some to this module.\n * Be careful with balance checks.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to issue\n * @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user \n * or left in the vault\n */\n function issueRebalancingSetWrappingEther(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n external\n payable\n nonReentrant\n {\n // Get baseSet address and quantity required for issuance of Rebalancing Set\n (\n address baseSetAddress,\n uint256 requiredBaseSetQuantity\n ) = getBaseSetAddressAndQuantity(_rebalancingSetAddress, _rebalancingSetQuantity);\n\n // Validate that WETH is a component of baseSet\n validateWETHIsAComponentOfSet(baseSetAddress, address(weth));\n\n // Deposit all the required non-weth components to the vault under the name of this contract\n // The required ether is wrapped and approved to the transferProxy\n depositComponentsAndHandleEth(\n baseSetAddress,\n requiredBaseSetQuantity\n );\n\n // Issue base SetToken to this contract, with the base SetToken held in the Vault\n coreInstance.issueInVault(\n baseSetAddress,\n requiredBaseSetQuantity\n );\n\n // Note: Don't need to set allowance of the base SetToken as the base SetToken is already in the vault\n\n // Issue rebalancing SetToken to the sender and return any excess base to sender\n issueRebalancingSetAndReturnExcessBase(\n _rebalancingSetAddress,\n baseSetAddress,\n _rebalancingSetQuantity,\n _keepChangeInVault\n );\n\n // Any eth that is not wrapped is sent back to the user\n // Only the amount required for the base SetToken issuance is wrapped.\n uint256 leftoverEth = address(this).balance;\n if (leftoverEth > 0) {\n msg.sender.transfer(leftoverEth);\n }\n }\n\n /**\n * Redeems a rebalancing SetToken into the base components of the base SetToken.\n * NOTE: Potential to receive more baseSet than expected if someone transfers some to this module.\n * Be careful with balance checks.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to redeem\n * @param _rebalancingSetQuantity The Quantity of the rebalancing SetToken to redeem\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user \n * or left in the vault\n */\n function redeemRebalancingSet(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n external\n nonReentrant\n {\n // Validate the rebalancing SetToken is valid and the quantity is a multiple of the natural unit\n validateRebalancingSetIssuance(_rebalancingSetAddress, _rebalancingSetQuantity);\n\n // Redeem RB Set to the vault attributed to this contract\n coreInstance.redeemModule(\n msg.sender,\n address(this),\n _rebalancingSetAddress,\n _rebalancingSetQuantity\n );\n\n // Calculate the base SetToken Redeem quantity\n address baseSetAddress = IRebalancingSetToken(_rebalancingSetAddress).currentSet();\n uint256 baseSetRedeemQuantity = getBaseSetRedeemQuantity(baseSetAddress);\n\n // Withdraw base SetToken to this contract\n coreInstance.withdraw(\n baseSetAddress,\n baseSetRedeemQuantity\n );\n\n // Redeem base SetToken and send components to the the user\n // Set exclude to 0, as tokens in rebalancing SetToken are already whitelisted\n coreInstance.redeemAndWithdrawTo(\n baseSetAddress,\n msg.sender,\n baseSetRedeemQuantity,\n 0\n );\n\n // Transfer any change of the base SetToken to the end user\n returnExcessBaseSet(baseSetAddress, transferProxy, _keepChangeInVault);\n\n // Log RebalancingSetRedeem\n emit LogRebalancingSetRedeem(\n _rebalancingSetAddress,\n msg.sender,\n _rebalancingSetQuantity\n );\n }\n\n /**\n * Redeems a rebalancing SetToken into the base components of the base SetToken. Unwraps\n * wrapped ether and sends eth to the user. If no wrapped ether in Set then will REVERT.\n * NOTE: Potential to receive more baseSet and ether dust than expected if someone transfers some to this module.\n * Be careful with balance checks.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to redeem\n * @param _rebalancingSetQuantity The Quantity of the rebalancing SetToken to redeem\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user \n * or left in the vault\n */\n function redeemRebalancingSetUnwrappingEther(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n external\n nonReentrant\n {\n // Validate the rebalancing SetToken is valid and the quantity is a multiple of the natural unit\n validateRebalancingSetIssuance(_rebalancingSetAddress, _rebalancingSetQuantity);\n\n address baseSetAddress = IRebalancingSetToken(_rebalancingSetAddress).currentSet();\n\n validateWETHIsAComponentOfSet(baseSetAddress, address(weth));\n\n // Redeem rebalancing SetToken to the vault attributed to this contract\n coreInstance.redeemModule(\n msg.sender,\n address(this),\n _rebalancingSetAddress,\n _rebalancingSetQuantity\n );\n\n // Calculate the base SetToken Redeem quantity\n uint256 baseSetRedeemQuantity = getBaseSetRedeemQuantity(baseSetAddress);\n\n // Withdraw base SetToken to this contract\n coreInstance.withdraw(\n baseSetAddress,\n baseSetRedeemQuantity\n );\n\n // Redeem the base SetToken. The components stay in the vault\n coreInstance.redeem(\n baseSetAddress,\n baseSetRedeemQuantity\n );\n\n // Loop through the base SetToken components and transfer to sender.\n withdrawComponentsToSenderWithEther(baseSetAddress);\n\n // Transfer any change of the base SetToken to the end user\n returnExcessBaseSet(baseSetAddress, transferProxy, _keepChangeInVault);\n\n // Log RebalancingSetRedeem\n emit LogRebalancingSetRedeem(\n _rebalancingSetAddress,\n msg.sender,\n _rebalancingSetQuantity\n );\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Gets base set address from rebalancing set token and calculates amount of base set needed\n * for issuance.\n *\n * @param _rebalancingSetAddress Address of the RebalancingSetToken to issue\n * @param _rebalancingSetQuantity The Quantity of the rebalancing SetToken to issue\n * @return baseSetAddress The address of RebalancingSet's base SetToken\n * @return requiredBaseSetQuantity The quantity of base SetToken to issue\n */\n function getBaseSetAddressAndQuantity(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity\n )\n internal\n view\n returns (address, uint256)\n {\n // Validate the rebalancing SetToken is valid and the quantity is a multiple of the natural unit\n validateRebalancingSetIssuance(_rebalancingSetAddress, _rebalancingSetQuantity);\n\n address baseSetAddress = IRebalancingSetToken(_rebalancingSetAddress).currentSet();\n\n // Calculate required base SetToken quantity\n uint256 requiredBaseSetQuantity = getBaseSetIssuanceRequiredQuantity(\n _rebalancingSetAddress,\n _rebalancingSetQuantity\n );\n\n return (baseSetAddress, requiredBaseSetQuantity); \n }\n\n /**\n * Issues the rebalancing set token to sender and returns any excess baseSet.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to issue\n * @param _baseSetAddress Address of the rebalancing SetToken's base set\n * @param _rebalancingSetQuantity The Quantity of the rebalancing SetToken to redeem\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user \n * or left in the vault\n */\n function issueRebalancingSetAndReturnExcessBase(\n address _rebalancingSetAddress,\n address _baseSetAddress,\n uint256 _rebalancingSetQuantity,\n bool _keepChangeInVault\n )\n internal\n {\n // Issue rebalancing SetToken to the sender\n coreInstance.issueTo(\n msg.sender,\n _rebalancingSetAddress,\n _rebalancingSetQuantity\n );\n\n // Return any excess base SetToken token to the sender\n returnExcessBaseSet(_baseSetAddress, transferProxy, _keepChangeInVault);\n\n // Log RebalancingSetIssue\n emit LogRebalancingSetIssue(\n _rebalancingSetAddress,\n msg.sender,\n _rebalancingSetQuantity\n ); \n }\n\n /**\n * During issuance, deposit the required quantity of base SetToken, wrap Ether, and deposit components\n * (excluding Ether, which is deposited during issuance) to the Vault in the name of the module.\n *\n * @param _baseSetAddress Address of the base SetToken token\n * @param _baseSetQuantity The Quantity of the base SetToken token to issue\n */\n function depositComponentsAndHandleEth(\n address _baseSetAddress,\n uint256 _baseSetQuantity\n )\n private\n {\n ISetToken baseSet = ISetToken(_baseSetAddress);\n\n address[] memory baseSetComponents = baseSet.getComponents();\n uint256[] memory baseSetUnits = baseSet.getUnits();\n uint256 baseSetNaturalUnit = baseSet.naturalUnit();\n\n // Loop through the base SetToken components and deposit components \n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n address currentComponent = baseSetComponents[i];\n uint256 currentUnit = baseSetUnits[i];\n\n // Calculate required component quantity\n uint256 currentComponentQuantity = _baseSetQuantity.div(baseSetNaturalUnit).mul(currentUnit);\n\n // If address is weth, deposit weth and transfer eth\n if (currentComponent == address(weth)) {\n // Expect the ether included exceeds the required Weth quantity\n require(\n msg.value >= currentComponentQuantity,\n \"RebalancingSetIssuanceModule.depositComponentsAndHandleEth: Not enough ether included for base SetToken\"\n );\n\n // wrap the required ether quantity\n weth.deposit.value(currentComponentQuantity)();\n\n // Ensure weth allowance\n ERC20Wrapper.ensureAllowance(\n address(weth),\n address(this),\n transferProxy,\n currentComponentQuantity\n );\n } else {\n // Deposit components to the vault in the name of the contract\n coreInstance.depositModule(\n msg.sender,\n address(this),\n currentComponent,\n currentComponentQuantity\n ); \n }\n }\n }\n\n /**\n * During redemption, withdraw the required quantity of base SetToken, unwrapping Ether, and withdraw\n * components to the sender\n *\n * @param _baseSetAddress Address of the base SetToken\n */\n function withdrawComponentsToSenderWithEther(\n address _baseSetAddress\n )\n private\n {\n address[] memory baseSetComponents = ISetToken(_baseSetAddress).getComponents();\n\n // Loop through the base SetToken components.\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n address currentComponent = baseSetComponents[i];\n uint256 currentComponentQuantity = vaultInstance.getOwnerBalance(\n currentComponent,\n address(this)\n );\n\n // If address is weth, withdraw weth and transfer eth to sender\n if (currentComponent == address(weth)) {\n // Transfer the wrapped ether to this address from the Vault\n coreInstance.withdrawModule(\n address(this),\n address(this),\n address(weth),\n currentComponentQuantity\n );\n\n // Unwrap wrapped ether\n weth.withdraw(currentComponentQuantity);\n\n // Transfer to recipient\n msg.sender.transfer(currentComponentQuantity);\n } else {\n // Withdraw component from the Vault and send to the user\n coreInstance.withdrawModule(\n address(this),\n msg.sender,\n currentComponent,\n currentComponentQuantity\n );\n }\n }\n }\n}"
},
{
"path": "contracts/core/modules/lib/CTokenWhiteListed.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ERC20Wrapper } from \"../../../lib/ERC20Wrapper.sol\";\nimport { IAddressToAddressWhiteList } from \"../../interfaces/IAddressToAddressWhiteList.sol\";\n\n\n/**\n * @title CTokenWhiteListed\n * @author Set Protocol\n *\n * The CTokenWhiteListed contract maintains cToken related state for modules that interact with cTokens. \n * Note: cETH is not supported.\n *\n */\ncontract CTokenWhiteListed {\n\n /* ============ State Variables ============ */\n\n // Address and instance of AddressToAddressWhiteList contract\n IAddressToAddressWhiteList public cTokenWhiteList; \n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for CTokenWhiteListed\n *\n * @param _transferProxy The address of TransferProxy\n * @param _cTokenWhiteList The instance of cTokenWhiteList contract\n */\n constructor(\n address _transferProxy,\n IAddressToAddressWhiteList _cTokenWhiteList\n )\n public\n {\n // Note: transferProxy is not committed here. Only used for token approvals\n cTokenWhiteList = _cTokenWhiteList;\n\n // Note: We do not expect there to be many validAddresses, so we won't hit gas limit\n address[] memory cTokenAddresses = _cTokenWhiteList.validAddresses();\n\n for (uint256 i = 0; i < cTokenAddresses.length; i++) {\n address cTokenAddress = cTokenAddresses[i];\n address underlyingAddress = cTokenWhiteList.getValue(cTokenAddress);\n\n // Add approvals of the underlying token to the cToken contract\n ERC20Wrapper.approve(\n underlyingAddress,\n cTokenAddress,\n CommonMath.maxUInt256()\n );\n\n // Add approvals of the underlying token to the transferProxy contract\n ERC20Wrapper.approve(\n underlyingAddress,\n _transferProxy,\n CommonMath.maxUInt256()\n );\n\n // Add approvals of the cToken to the transferProxy contract\n ERC20Wrapper.approve(\n cTokenAddress,\n _transferProxy,\n CommonMath.maxUInt256()\n );\n }\n }\n}\n"
},
{
"path": "contracts/core/modules/lib/ExchangeExecution.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ExchangeHeaderLibrary } from \"../../lib/ExchangeHeaderLibrary.sol\";\nimport { ExchangeIssuanceLibrary } from \"./ExchangeIssuanceLibrary.sol\";\nimport { ExchangeWrapperLibrary } from \"../../lib/ExchangeWrapperLibrary.sol\";\nimport { ExchangeWrapperLibraryV2 } from \"../../lib/ExchangeWrapperLibraryV2.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { ModuleCoreState } from \"./ModuleCoreState.sol\";\n\n\n/**\n * @title ExchangeExecution\n * @author Set Protocol\n *\n * The ExchangeExecution contract exposes functions that allow validation and execution of exchange orders.\n */\ncontract ExchangeExecution is\n ModuleCoreState\n{\n using SafeMath for uint256;\n\n /* ============ Private Functions ============ */\n\n /**\n * Execute the exchange orders by parsing the order data and facilitating the transfers. Each\n * header represents a batch of orders for a particular exchange (0x, Kyber)\n *\n * @param _orderData Bytes array containing the exchange orders to execute\n */\n function executeExchangeOrders(\n bytes memory _orderData\n )\n internal\n {\n // Bitmask integer of called exchanges. Acts as a lock so that duplicate exchange headers are not passed in.\n uint256 calledExchanges = 0;\n \n uint256 scannedBytes = 0;\n while (scannedBytes < _orderData.length) {\n // Parse exchange header based on scannedBytes\n ExchangeHeaderLibrary.ExchangeHeader memory header = ExchangeHeaderLibrary.parseExchangeHeader(\n _orderData,\n scannedBytes\n );\n\n // Get exchange address from state mapping based on header exchange info\n address exchangeWrapper = coreInstance.exchangeIds(header.exchange);\n\n // Verify exchange address is registered\n require(\n exchangeWrapper != address(0),\n \"ExchangeExecution.executeExchangeOrders: Invalid or disabled Exchange address\"\n );\n\n // Verify exchange has not already been called\n uint256 exchangeBitIndex = CommonMath.safePower(2, header.exchange);\n require(\n (calledExchanges & exchangeBitIndex) == 0,\n \"ExchangeExecution.executeExchangeOrders: Exchange already called\"\n );\n\n // Calculate the exchange data length\n uint256 exchangeDataLength = header.orderDataBytesLength.add(\n ExchangeHeaderLibrary.EXCHANGE_HEADER_LENGTH()\n );\n\n // Read the order body based on order data length info in header plus the length of the header\n bytes memory bodyData = ExchangeHeaderLibrary.sliceBodyData(\n _orderData,\n scannedBytes,\n exchangeDataLength\n );\n\n // Construct the Exchange Data struct for callExchange interface\n ExchangeWrapperLibraryV2.ExchangeData memory exchangeData = ExchangeWrapperLibraryV2.ExchangeData({\n caller: msg.sender,\n orderCount: header.orderCount\n });\n\n // Execute orders using the appropriate exchange wrappers\n ExchangeWrapperLibrary.callExchange(\n core,\n exchangeData,\n exchangeWrapper,\n bodyData\n );\n\n // Update scanned bytes with header and body lengths\n scannedBytes = scannedBytes.add(exchangeDataLength);\n\n // Increment bit of current exchange to ensure non-duplicate entries\n calledExchanges = calledExchanges.add(exchangeBitIndex);\n }\n }\n\n /**\n * Calculates the user's balance of tokens required after exchange orders have been executed\n *\n * @param _exchangeIssuanceParams A Struct containing exchange issuance metadata\n * @return uint256[] Expected token balances after order execution\n */\n function calculateReceiveTokenBalances(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams\n )\n internal\n view\n returns (uint256[] memory)\n {\n // Calculate amount of receive tokens required\n uint256[] memory requiredBalances = new uint256[](_exchangeIssuanceParams.receiveTokens.length);\n for (uint256 i = 0; i < _exchangeIssuanceParams.receiveTokens.length; i++) {\n // Get the user's current vault balances\n uint256 tokenBalance = vaultInstance.getOwnerBalance(\n _exchangeIssuanceParams.receiveTokens[i],\n msg.sender\n );\n\n // Amount of receive tokens to be added to Vault\n uint256 requiredAddition = _exchangeIssuanceParams.receiveTokenAmounts[i];\n\n // Required vault balances after exchange order execution\n requiredBalances[i] = tokenBalance.add(requiredAddition);\n }\n\n return requiredBalances;\n }\n\n /**\n * Validates exchangeIssueParam inputs\n *\n * @param _exchangeIssuanceParams A Struct containing exchange issuance metadata\n */\n function validateExchangeIssuanceParams(\n ExchangeIssuanceLibrary.ExchangeIssuanceParams memory _exchangeIssuanceParams\n )\n internal\n view\n {\n // Verify Set was created by Core and is enabled\n require(\n coreInstance.validSets(_exchangeIssuanceParams.setAddress),\n \"ExchangeExecution.validateExchangeIssuanceParams: Invalid or disabled SetToken address\"\n );\n\n // Validate the issuance quantity\n ExchangeIssuanceLibrary.validateQuantity(\n _exchangeIssuanceParams.setAddress,\n _exchangeIssuanceParams.quantity\n );\n\n // Validate send token data\n ExchangeIssuanceLibrary.validateSendTokenParams(\n core,\n _exchangeIssuanceParams.sendTokenExchangeIds,\n _exchangeIssuanceParams.sendTokens,\n _exchangeIssuanceParams.sendTokenAmounts\n );\n\n // Validate receive token inputs\n ExchangeIssuanceLibrary.validateReceiveTokens(\n _exchangeIssuanceParams.receiveTokens,\n _exchangeIssuanceParams.receiveTokenAmounts\n );\n }\n}\n"
},
{
"path": "contracts/core/modules/lib/ExchangeIssuanceLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { IVault } from \"../../interfaces/IVault.sol\";\n\n\n/**\n * @title ExchangeIssuanceLibrary\n * @author Set Protocol\n *\n * The ExchangeIssuanceLibrary contains functions for validating exchange order data\n */\nlibrary ExchangeIssuanceLibrary {\n using SafeMath for uint256;\n using AddressArrayUtils for address[];\n\n // ============ Structs ============\n\n struct ExchangeIssuanceParams {\n address setAddress;\n uint256 quantity;\n uint8[] sendTokenExchangeIds;\n address[] sendTokens;\n uint256[] sendTokenAmounts;\n address[] receiveTokens;\n uint256[] receiveTokenAmounts;\n }\n\n /**\n * Validates that the quantity to issue is positive and a multiple of the Set natural unit.\n *\n * @param _set The address of the Set\n * @param _quantity The quantity of Sets to issue or redeem\n */\n function validateQuantity(\n address _set,\n uint256 _quantity\n )\n internal\n view\n {\n // Make sure quantity to issue is greater than 0\n require(\n _quantity > 0,\n \"ExchangeIssuanceLibrary.validateQuantity: Quantity must be positive\"\n );\n\n // Make sure Issue quantity is multiple of the Set natural unit\n require(\n _quantity.mod(ISetToken(_set).naturalUnit()) == 0,\n \"ExchangeIssuanceLibrary.validateQuantity: Quantity must be multiple of natural unit\"\n );\n }\n\n /**\n * Validates that the required Components and amounts are valid components and positive.\n * Duplicate receive token values are not allowed\n *\n * @param _receiveTokens The addresses of components required for issuance\n * @param _receiveTokenAmounts The quantities of components required for issuance\n */\n function validateReceiveTokens(\n address[] memory _receiveTokens,\n uint256[] memory _receiveTokenAmounts\n )\n internal\n view\n {\n uint256 receiveTokensCount = _receiveTokens.length;\n\n // Make sure required components array is non-empty\n require(\n receiveTokensCount > 0,\n \"ExchangeIssuanceLibrary.validateReceiveTokens: Receive tokens must not be empty\"\n );\n\n // Ensure the receive tokens has no duplicates\n require(\n !_receiveTokens.hasDuplicate(),\n \"ExchangeIssuanceLibrary.validateReceiveTokens: Receive tokens must not have duplicates\"\n );\n\n // Make sure required components and required component amounts are equal length\n require(\n receiveTokensCount == _receiveTokenAmounts.length,\n \"ExchangeIssuanceLibrary.validateReceiveTokens: Receive tokens and amounts must be equal length\"\n );\n\n for (uint256 i = 0; i < receiveTokensCount; i++) {\n // Make sure all required component amounts are non-zero\n require(\n _receiveTokenAmounts[i] > 0,\n \"ExchangeIssuanceLibrary.validateReceiveTokens: Component amounts must be positive\"\n );\n }\n }\n\n /**\n * Validates that the tokens received exceeds what we expect\n *\n * @param _vault The address of the Vault\n * @param _receiveTokens The addresses of components required for issuance\n * @param _requiredBalances The quantities of components required for issuance\n * @param _userToCheck The address of the user\n */\n function validatePostExchangeReceiveTokenBalances(\n address _vault,\n address[] memory _receiveTokens,\n uint256[] memory _requiredBalances,\n address _userToCheck\n )\n internal\n view\n {\n // Get vault instance\n IVault vault = IVault(_vault);\n\n // Check that caller's receive tokens in Vault have been incremented correctly\n for (uint256 i = 0; i < _receiveTokens.length; i++) {\n uint256 currentBal = vault.getOwnerBalance(\n _receiveTokens[i],\n _userToCheck\n );\n\n require(\n currentBal >= _requiredBalances[i],\n \"ExchangeIssuanceLibrary.validatePostExchangeReceiveTokenBalances: Insufficient receive token acquired\"\n );\n }\n }\n\n /**\n * Validates that the send tokens inputs are valid. Since tokens are sent to various exchanges,\n * duplicate send tokens are valid\n *\n * @param _core The address of Core\n * @param _sendTokenExchangeIds List of exchange wrapper enumerations corresponding to \n * the wrapper that will handle the component\n * @param _sendTokens The address of the send tokens\n * @param _sendTokenAmounts The quantities of send tokens\n */\n function validateSendTokenParams(\n address _core,\n uint8[] memory _sendTokenExchangeIds,\n address[] memory _sendTokens,\n uint256[] memory _sendTokenAmounts\n )\n internal\n view\n {\n require(\n _sendTokens.length > 0,\n \"ExchangeIssuanceLibrary.validateSendTokenParams: Send token inputs must not be empty\"\n );\n\n require(\n _sendTokenExchangeIds.length == _sendTokens.length && \n _sendTokens.length == _sendTokenAmounts.length,\n \"ExchangeIssuanceLibrary.validateSendTokenParams: Send token inputs must be of the same length\"\n );\n\n ICore core = ICore(_core);\n\n for (uint256 i = 0; i < _sendTokenExchangeIds.length; i++) {\n // Make sure all exchanges are valid\n require(\n core.exchangeIds(_sendTokenExchangeIds[i]) != address(0),\n \"ExchangeIssuanceLibrary.validateSendTokenParams: Must be valid exchange\"\n );\n\n // Make sure all send token amounts are non-zero\n require(\n _sendTokenAmounts[i] > 0,\n \"ExchangeIssuanceLibrary.validateSendTokenParams: Send amounts must be positive\"\n );\n }\n }\n}\n"
},
{
"path": "contracts/core/modules/lib/ModuleCoreState.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { ITransferProxy } from \"../../interfaces/ITransferProxy.sol\";\nimport { IVault } from \"../../interfaces/IVault.sol\";\n\n\n/**\n * @title ModuleCoreState\n * @author Set Protocol\n *\n * The ModuleCoreState library maintains Core-related state for modules\n */\ncontract ModuleCoreState {\n\n /* ============ State Variables ============ */\n\n // Address of core contract\n address public core;\n\n // Address of vault contract\n address public vault;\n\n // Instance of core contract\n ICore public coreInstance;\n\n // Instance of vault contract\n IVault public vaultInstance;\n\n /* ============ Public Getters ============ */\n\n /**\n * Constructor function for ModuleCoreState\n *\n * @param _core The address of Core\n * @param _vault The address of Vault\n */\n constructor(\n address _core,\n address _vault\n )\n public\n {\n // Commit passed address to core state variable\n core = _core;\n\n // Commit passed address to coreInstance state variable\n coreInstance = ICore(_core);\n\n // Commit passed address to vault state variable\n vault = _vault;\n\n // Commit passed address to vaultInstance state variable\n vaultInstance = IVault(_vault);\n }\n}\n"
},
{
"path": "contracts/core/modules/lib/ModuleCoreStateV2.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { ITransferProxy } from \"../../interfaces/ITransferProxy.sol\";\nimport { IVault } from \"../../interfaces/IVault.sol\";\n\n\n/**\n * @title ModuleCoreStateV2\n * @author Set Protocol\n *\n * The ModuleCoreStateV2 library maintains Core-related state for modules.\n *\n * CHANGELOG\n * - Adds transferProxy to the tracked state\n * - Removes address variables\n *\n */\ncontract ModuleCoreStateV2 {\n\n /* ============ State Variables ============ */\n\n // Address of core contract\n ICore public coreInstance;\n\n // Address of vault contract\n IVault public vaultInstance;\n\n // Address of transferProxy contract\n ITransferProxy public transferProxyInstance;\n\n /* ============ Public Getters ============ */\n\n /**\n * Constructor function for ModuleCoreStateV2\n *\n * @param _core The address of Core\n * @param _vault The address of Vault\n * @param _transferProxy The address of TransferProxy\n */\n constructor(\n ICore _core,\n IVault _vault,\n ITransferProxy _transferProxy\n )\n public\n {\n // Commit passed address to core state variable\n coreInstance = _core;\n\n // Commit passed address to vault state variable\n vaultInstance = _vault;\n\n // Commit passed address to vault state variable\n transferProxyInstance = _transferProxy;\n }\n}\n"
},
{
"path": "contracts/core/modules/lib/RebalancingSetIssuance.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\n\nimport { ERC20Wrapper } from \"../../../lib/ERC20Wrapper.sol\";\nimport { IRebalancingSetToken } from \"../../interfaces/IRebalancingSetToken.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { ModuleCoreState } from \"./ModuleCoreState.sol\";\n\n\n/**\n * @title RebalancingSetIssuance\n * @author Set Protocol\n *\n * The RebalancingSetIssuance contains utility functions used in rebalancing SetToken \n * issuance\n */\ncontract RebalancingSetIssuance is \n ModuleCoreState\n{\n using SafeMath for uint256;\n using AddressArrayUtils for address[];\n\n // ============ Internal ============\n\n /**\n * Validates that wrapped Ether is a component of the SetToken\n *\n * @param _setAddress Address of the SetToken\n * @param _wrappedEtherAddress Address of wrapped Ether\n */\n function validateWETHIsAComponentOfSet(\n address _setAddress,\n address _wrappedEtherAddress\n )\n internal\n view\n {\n require(\n ISetToken(_setAddress).tokenIsComponent(_wrappedEtherAddress),\n \"RebalancingSetIssuance.validateWETHIsAComponentOfSet: Components must contain weth\"\n );\n }\n\n /**\n * Validates that the passed in address is tracked by Core and that the quantity\n * is a multiple of the natural unit\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to issue/redeem\n * @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken\n */ \n function validateRebalancingSetIssuance(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity\n ) \n internal\n view\n {\n // Expect rebalancing SetToken to be valid and enabled SetToken\n require(\n coreInstance.validSets(_rebalancingSetAddress),\n \"RebalancingSetIssuance.validateRebalancingIssuance: Invalid or disabled SetToken address\"\n );\n \n // Make sure Issuance quantity is multiple of the rebalancing SetToken natural unit\n require(\n _rebalancingSetQuantity.mod(ISetToken(_rebalancingSetAddress).naturalUnit()) == 0,\n \"RebalancingSetIssuance.validateRebalancingIssuance: Quantity must be multiple of natural unit\"\n );\n }\n\n /**\n * Given a rebalancing SetToken and a desired issue quantity, calculates the \n * minimum issuable quantity of the base SetToken. If the calculated quantity is initially\n * not a multiple of the base SetToken's natural unit, the quantity is rounded up\n * to the next base set natural unit.\n *\n * @param _rebalancingSetAddress Address of the rebalancing SetToken to issue\n * @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken\n * @return requiredBaseSetQuantity The quantity of base SetToken to issue\n */ \n function getBaseSetIssuanceRequiredQuantity(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity\n )\n internal\n view\n returns (uint256)\n {\n IRebalancingSetToken rebalancingSet = IRebalancingSetToken(_rebalancingSetAddress);\n\n uint256 unitShares = rebalancingSet.unitShares();\n uint256 naturalUnit = rebalancingSet.naturalUnit();\n\n uint256 requiredBaseSetQuantity = _rebalancingSetQuantity.div(naturalUnit).mul(unitShares);\n\n address baseSet = rebalancingSet.currentSet();\n uint256 baseSetNaturalUnit = ISetToken(baseSet).naturalUnit();\n\n // If there is a mismatch between the required quantity and the base SetToken natural unit,\n // round up to the next base SetToken natural unit if required.\n uint256 roundDownQuantity = requiredBaseSetQuantity.mod(baseSetNaturalUnit);\n if (roundDownQuantity > 0) {\n requiredBaseSetQuantity = requiredBaseSetQuantity.sub(roundDownQuantity).add(baseSetNaturalUnit);\n }\n\n return requiredBaseSetQuantity;\n }\n\n\n /**\n * Given a rebalancing SetToken address, retrieve the base SetToken quantity redeem quantity based on the quantity\n * held in the Vault. Rounds down to the nearest base SetToken natural unit\n *\n * @param _baseSetAddress The address of the base SetToken\n * @return baseSetRedeemQuantity The quantity of base SetToken to redeem\n */\n function getBaseSetRedeemQuantity(\n address _baseSetAddress\n )\n internal\n view\n returns (uint256)\n {\n // Get base SetToken Details from the rebalancing SetToken\n uint256 baseSetNaturalUnit = ISetToken(_baseSetAddress).naturalUnit();\n uint256 baseSetBalance = vaultInstance.getOwnerBalance(\n _baseSetAddress,\n address(this)\n );\n\n // Round the balance down to the base SetToken natural unit and return\n return baseSetBalance.sub(baseSetBalance.mod(baseSetNaturalUnit));\n }\n\n /**\n * Checks the base SetToken balances in the Vault and on the contract. \n * Sends any positive quantity to the user directly or into the Vault\n * depending on the keepChangeInVault flag.\n *\n * @param _baseSetAddress The address of the base SetToken\n * @param _transferProxyAddress The address of the TransferProxy\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user \n * or left in the vault\n */\n function returnExcessBaseSet(\n address _baseSetAddress,\n address _transferProxyAddress,\n bool _keepChangeInVault\n )\n internal\n {\n returnExcessBaseSetFromContract(_baseSetAddress, _transferProxyAddress, _keepChangeInVault);\n\n returnExcessBaseSetInVault(_baseSetAddress, _keepChangeInVault);\n } \n\n /**\n * Checks the base SetToken balances on the contract and sends\n * any positive quantity to the user directly or into the Vault\n * depending on the keepChangeInVault flag.\n *\n * @param _baseSetAddress The address of the base SetToken\n * @param _transferProxyAddress The address of the TransferProxy\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user \n * or left in the vault\n */\n function returnExcessBaseSetFromContract(\n address _baseSetAddress,\n address _transferProxyAddress,\n bool _keepChangeInVault\n )\n internal\n {\n uint256 baseSetQuantity = ERC20Wrapper.balanceOf(_baseSetAddress, address(this));\n \n if (baseSetQuantity == 0) { \n return; \n } else if (_keepChangeInVault) {\n // Ensure base SetToken allowance\n ERC20Wrapper.ensureAllowance(\n _baseSetAddress,\n address(this),\n _transferProxyAddress,\n baseSetQuantity\n );\n\n // Deposit base SetToken to the user\n coreInstance.depositModule(\n address(this),\n msg.sender,\n _baseSetAddress,\n baseSetQuantity\n );\n } else {\n // Transfer directly to the user\n ERC20Wrapper.transfer(\n _baseSetAddress,\n msg.sender,\n baseSetQuantity\n );\n }\n }\n\n /**\n * Checks the base SetToken balances in the Vault and sends\n * any positive quantity to the user directly or into the Vault\n * depending on the keepChangeInVault flag.\n *\n * @param _baseSetAddress The address of the base SetToken\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user \n * or left in the vault\n */\n function returnExcessBaseSetInVault(\n address _baseSetAddress,\n bool _keepChangeInVault\n )\n internal\n {\n // Return base SetToken if any that are in the Vault\n uint256 baseSetQuantityInVault = vaultInstance.getOwnerBalance(\n _baseSetAddress,\n address(this)\n );\n \n if (baseSetQuantityInVault == 0) { \n return; \n } else if (_keepChangeInVault) {\n // Transfer ownership within the vault to the user\n coreInstance.internalTransfer(\n _baseSetAddress,\n msg.sender,\n baseSetQuantityInVault\n );\n } else {\n // Transfer ownership directly to the user\n coreInstance.withdrawModule(\n address(this),\n msg.sender,\n _baseSetAddress,\n baseSetQuantityInVault\n );\n }\n } \n}\n"
},
{
"path": "contracts/core/modules/lib/TokenFlush.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\n\nimport { ERC20Wrapper } from \"../../../lib/ERC20Wrapper.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { ModuleCoreStateV2 } from \"./ModuleCoreStateV2.sol\";\n\n\n/**\n * @title TokenFlush\n * @author Set Protocol\n *\n * The TokenFlush contains utility functions to send tokens and base SetTokens from the\n * Vault or Contract to a specified user address\n */\ncontract TokenFlush is \n ModuleCoreStateV2\n{\n using SafeMath for uint256;\n using AddressArrayUtils for address[];\n\n // ============ Internal ============\n\n /**\n * Checks the base SetToken balances on the contract and sends\n * any positive quantity to the user directly or into the Vault\n * depending on the keepChangeInVault flag.\n *\n * @param _baseSetAddress The address of the base SetToken\n * @param _returnAddress The address to send excess tokens to\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user \n * or left in the vault\n */\n function returnExcessBaseSetFromContract(\n address _baseSetAddress,\n address _returnAddress,\n bool _keepChangeInVault\n )\n internal\n {\n uint256 baseSetQuantity = ERC20Wrapper.balanceOf(_baseSetAddress, address(this));\n \n if (baseSetQuantity > 0) { \n if (_keepChangeInVault) {\n // Ensure base SetToken allowance\n ERC20Wrapper.ensureAllowance(\n _baseSetAddress,\n address(this),\n address(transferProxyInstance),\n baseSetQuantity\n );\n\n // Deposit base SetToken to the user\n coreInstance.depositModule(\n address(this),\n _returnAddress,\n _baseSetAddress,\n baseSetQuantity\n );\n } else {\n // Transfer directly to the user\n ERC20Wrapper.transfer(\n _baseSetAddress,\n _returnAddress,\n baseSetQuantity\n );\n }\n }\n }\n\n /**\n * Checks the base SetToken balances in the Vault and sends\n * any positive quantity to the user directly or into the Vault\n * depending on the keepChangeInVault flag.\n *\n * @param _baseSetAddress The address of the base SetToken\n * @param _returnAddress The address to send excess tokens to\n * @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user \n * or left in the vault\n */\n function returnExcessBaseSetInVault(\n address _baseSetAddress,\n address _returnAddress,\n bool _keepChangeInVault\n )\n internal\n {\n // Return base SetToken if any that are in the Vault\n uint256 baseSetQuantityInVault = vaultInstance.getOwnerBalance(\n _baseSetAddress,\n address(this)\n );\n \n if (baseSetQuantityInVault > 0) { \n if (_keepChangeInVault) {\n // Transfer ownership within the vault to the user\n coreInstance.internalTransfer(\n _baseSetAddress,\n _returnAddress,\n baseSetQuantityInVault\n );\n } else {\n // Transfer ownership directly to the user\n coreInstance.withdrawModule(\n address(this),\n _returnAddress,\n _baseSetAddress,\n baseSetQuantityInVault\n );\n }\n }\n } \n\n /**\n * Withdraw any base Set components to the user from the contract.\n *\n * @param _baseSetToken Instance of the Base SetToken\n * @param _returnAddress The address to send excess tokens to\n */\n function returnExcessComponentsFromContract(\n ISetToken _baseSetToken,\n address _returnAddress\n )\n internal\n {\n // Return base Set components\n address[] memory baseSetComponents = _baseSetToken.getComponents();\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n uint256 withdrawQuantity = ERC20Wrapper.balanceOf(baseSetComponents[i], address(this));\n if (withdrawQuantity > 0) {\n ERC20Wrapper.transfer(\n baseSetComponents[i],\n _returnAddress,\n withdrawQuantity\n );\n }\n } \n }\n\n /**\n * Any base Set components in the Vault are returned to the caller.\n *\n * @param _baseSetToken Instance of the Base SetToken\n * @param _returnAddress The address to send excess tokens to\n */\n function returnExcessComponentsFromVault(\n ISetToken _baseSetToken,\n address _returnAddress\n )\n internal\n {\n // Return base Set components not used in issuance of base set\n address[] memory baseSetComponents = _baseSetToken.getComponents();\n for (uint256 i = 0; i < baseSetComponents.length; i++) {\n uint256 vaultQuantity = vaultInstance.getOwnerBalance(baseSetComponents[i], address(this));\n if (vaultQuantity > 0) {\n coreInstance.withdrawModule(\n address(this),\n _returnAddress,\n baseSetComponents[i],\n vaultQuantity\n );\n }\n }\n } \n}\n"
},
{
"path": "contracts/core/tokens/RebalancingSetToken.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20 } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\nimport { ERC20Detailed } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IRebalancingSetFactory } from \"../interfaces/IRebalancingSetFactory.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\nimport { IWhiteList } from \"../interfaces/IWhiteList.sol\";\nimport { RebalancingLibrary } from \"../lib/RebalancingLibrary.sol\";\nimport { FailAuctionLibrary } from \"./rebalancing-libraries/FailAuctionLibrary.sol\";\nimport { PlaceBidLibrary } from \"./rebalancing-libraries/PlaceBidLibrary.sol\";\nimport { ProposeLibrary } from \"./rebalancing-libraries/ProposeLibrary.sol\";\nimport { SettleRebalanceLibrary } from \"./rebalancing-libraries/SettleRebalanceLibrary.sol\";\nimport { StartRebalanceLibrary } from \"./rebalancing-libraries/StartRebalanceLibrary.sol\";\n\n\n/**\n * @title RebalancingSetToken\n * @author Set Protocol\n *\n * Implementation of Rebalancing Set token.\n */\ncontract RebalancingSetToken is\n ERC20,\n ERC20Detailed\n{\n using SafeMath for uint256;\n\n /* ============ State Variables ============ */\n\n // Dependency variables\n address public core;\n address public factory;\n address public vault;\n address public componentWhiteListAddress;\n\n // Core and Vault instances\n ICore private coreInstance;\n IVault private vaultInstance;\n IWhiteList private componentWhiteListInstance;\n\n uint256 public naturalUnit;\n address public manager;\n RebalancingLibrary.State public rebalanceState;\n\n // State updated after every rebalance\n address public currentSet;\n uint256 public unitShares;\n uint256 public lastRebalanceTimestamp;\n\n // State governing rebalance cycle\n uint256 public proposalPeriod;\n uint256 public rebalanceInterval;\n\n // State to track proposal period\n uint256 public proposalStartTime;\n\n // State needed for auction/rebalance\n address public nextSet;\n address public auctionLibrary;\n uint256 public startingCurrentSetAmount;\n RebalancingLibrary.AuctionPriceParameters public auctionPriceParameters;\n RebalancingLibrary.BiddingParameters public biddingParameters;\n\n // To be used if token put into Drawdown State\n address[] public failedAuctionWithdrawComponents;\n\n /* ============ Events ============ */\n\n event NewManagerAdded(\n address newManager,\n address oldManager\n );\n\n event RebalanceProposed(\n address nextSet,\n address indexed auctionLibrary,\n uint256 indexed proposalPeriodEndTime\n );\n\n event RebalanceStarted(\n address oldSet,\n address newSet\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for Rebalancing Set Token\n *\n * @param _factory Factory used to create the Rebalancing Set\n * @param _manager Manager of the Rebalancing Set\n * @param _initialSet Initial set that collateralizes the Rebalancing set\n * @param _initialUnitShares Units of currentSet that equals one share\n * @param _naturalUnit The minimum multiple of Sets that can be issued or redeemed\n * @param _proposalPeriod Amount of time for users to inspect a rebalance proposal\n * @param _rebalanceInterval Minimum amount of time between rebalances\n * @param _componentWhiteList Address of component WhiteList contract\n * @param _name The name of the new RebalancingSetToken\n * @param _symbol The symbol of the new RebalancingSetToken\n */\n\n constructor(\n address _factory,\n address _manager,\n address _initialSet,\n uint256 _initialUnitShares,\n uint256 _naturalUnit,\n uint256 _proposalPeriod,\n uint256 _rebalanceInterval,\n address _componentWhiteList,\n string memory _name,\n string memory _symbol\n )\n public\n ERC20Detailed(\n _name,\n _symbol,\n 18\n )\n {\n // Require initial unit shares is non-zero\n require(\n _initialUnitShares > 0,\n \"RebalancingSetToken.constructor: Unit shares must be positive\"\n );\n\n IRebalancingSetFactory tokenFactory = IRebalancingSetFactory(_factory);\n\n require(\n _naturalUnit >= tokenFactory.minimumNaturalUnit(),\n \"RebalancingSetToken.constructor: Natural Unit too low\"\n );\n\n require(\n _naturalUnit <= tokenFactory.maximumNaturalUnit(),\n \"RebalancingSetToken.constructor: Natural Unit too large\"\n );\n\n // Require manager address is non-zero\n require(\n _manager != address(0),\n \"RebalancingSetToken.constructor: Invalid manager address\"\n );\n\n // Require minimum rebalance interval and proposal period from factory\n require(\n _proposalPeriod >= tokenFactory.minimumProposalPeriod(),\n \"RebalancingSetToken.constructor: Proposal period too short\"\n );\n require(\n _rebalanceInterval >= tokenFactory.minimumRebalanceInterval(),\n \"RebalancingSetToken.constructor: Rebalance interval too short\"\n );\n\n core = IRebalancingSetFactory(_factory).core();\n coreInstance = ICore(core);\n vault = coreInstance.vault();\n vaultInstance = IVault(vault);\n componentWhiteListAddress = _componentWhiteList;\n componentWhiteListInstance = IWhiteList(_componentWhiteList);\n factory = _factory;\n manager = _manager;\n currentSet = _initialSet;\n unitShares = _initialUnitShares;\n naturalUnit = _naturalUnit;\n\n proposalPeriod = _proposalPeriod;\n rebalanceInterval = _rebalanceInterval;\n lastRebalanceTimestamp = block.timestamp;\n rebalanceState = RebalancingLibrary.State.Default;\n }\n\n /* ============ Public Functions ============ */\n\n /**\n * Function used to set the terms of the next rebalance and start the proposal period\n *\n * @param _nextSet The Set to rebalance into\n * @param _auctionLibrary The library used to calculate the Dutch Auction price\n * @param _auctionTimeToPivot The amount of time for the auction to go ffrom start to pivot price\n * @param _auctionStartPrice The price to start the auction at\n * @param _auctionPivotPrice The price at which the price curve switches from linear to exponential\n */\n function propose(\n address _nextSet,\n address _auctionLibrary,\n uint256 _auctionTimeToPivot,\n uint256 _auctionStartPrice,\n uint256 _auctionPivotPrice\n )\n external\n {\n // Put together auction price parameters\n RebalancingLibrary.AuctionPriceParameters memory auctionPriceParams =\n RebalancingLibrary.AuctionPriceParameters({\n auctionTimeToPivot: _auctionTimeToPivot,\n auctionStartPrice: _auctionStartPrice,\n auctionPivotPrice: _auctionPivotPrice,\n auctionStartTime: 0\n });\n\n // Create ProposeAuctionParameters\n ProposeLibrary.ProposalContext memory proposalContext =\n ProposeLibrary.ProposalContext({\n manager: manager,\n currentSet: currentSet,\n coreAddress: core,\n componentWhitelist: componentWhiteListAddress,\n factoryAddress: factory,\n lastRebalanceTimestamp: lastRebalanceTimestamp,\n rebalanceInterval: rebalanceInterval,\n rebalanceState: uint8(rebalanceState)\n });\n\n // Validate proposal inputs and initialize auctionPriceParameters\n ProposeLibrary.validateProposal(\n _nextSet,\n _auctionLibrary,\n proposalContext,\n auctionPriceParams\n );\n\n // Update state parameters\n auctionPriceParameters = auctionPriceParams;\n nextSet = _nextSet;\n auctionLibrary = _auctionLibrary;\n proposalStartTime = block.timestamp;\n rebalanceState = RebalancingLibrary.State.Proposal;\n\n emit RebalanceProposed(\n _nextSet,\n _auctionLibrary,\n proposalStartTime.add(proposalPeriod)\n );\n }\n\n /*\n * Initiate rebalance for the rebalancing set if the proposal period has elapsed after\n * a proposal.\n */\n function startRebalance()\n external\n {\n // Validate the correct rebalance state and time elapsed\n StartRebalanceLibrary.validateStartRebalance(\n proposalStartTime,\n proposalPeriod,\n uint8(rebalanceState)\n );\n\n // Redeem currentSet and set up biddingParameters\n biddingParameters = StartRebalanceLibrary.redeemCurrentSetAndGetBiddingParameters(\n currentSet,\n nextSet,\n auctionLibrary,\n core,\n vault\n );\n\n // Update state parameters\n startingCurrentSetAmount = biddingParameters.remainingCurrentSets;\n auctionPriceParameters.auctionStartTime = block.timestamp;\n rebalanceState = RebalancingLibrary.State.Rebalance;\n\n emit RebalanceStarted(currentSet, nextSet);\n }\n\n /*\n * Initiate settlement for the rebalancing set. Full functionality now returned to\n * set owners\n *\n */\n function settleRebalance()\n external\n {\n // Settle the rebalance and mint next Sets\n unitShares = SettleRebalanceLibrary.settleRebalance(\n totalSupply(),\n biddingParameters.remainingCurrentSets,\n biddingParameters.minimumBid,\n naturalUnit,\n nextSet,\n core,\n vault,\n uint8(rebalanceState)\n );\n\n // Update other state parameters\n currentSet = nextSet;\n lastRebalanceTimestamp = block.timestamp;\n rebalanceState = RebalancingLibrary.State.Default;\n clearAuctionState();\n }\n\n /*\n * Place bid during rebalance auction. Can only be called by Core.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return combinedTokenArray Array of token addresses invovled in rebalancing\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function placeBid(\n uint256 _quantity\n )\n external\n returns (address[] memory, uint256[] memory, uint256[] memory)\n {\n // Validate bid quantity and module is sender\n PlaceBidLibrary.validatePlaceBid(\n _quantity,\n core,\n biddingParameters\n );\n\n // Place bid and get back inflow and outflow arrays\n uint256[] memory inflowUnitArray;\n uint256[] memory outflowUnitArray;\n (\n inflowUnitArray,\n outflowUnitArray\n ) = getBidPrice(_quantity);\n\n // Update remainingCurrentSet figure to account for placed bid\n biddingParameters.remainingCurrentSets = biddingParameters.remainingCurrentSets.sub(_quantity);\n\n return (biddingParameters.combinedTokenArray, inflowUnitArray, outflowUnitArray);\n }\n\n /*\n * Fail an auction that doesn't complete before reaching the pivot price. Move to Drawdown state\n * if bids have been placed. Reset to Default state if no bids placed.\n *\n */\n function endFailedAuction()\n external\n {\n uint256 calculatedUnitShares;\n (\n ,\n calculatedUnitShares\n ) = SettleRebalanceLibrary.calculateNextSetIssueQuantity(\n totalSupply(),\n naturalUnit,\n nextSet,\n vault\n );\n\n // Fail auction and either reset to Default state or kill Rebalancing Set Token and enter Drawdown\n // state\n uint8 integerRebalanceState = FailAuctionLibrary.endFailedAuction(\n startingCurrentSetAmount,\n calculatedUnitShares,\n currentSet,\n core,\n auctionPriceParameters,\n biddingParameters,\n uint8(rebalanceState)\n );\n rebalanceState = RebalancingLibrary.State(integerRebalanceState);\n\n // Reset lastRebalanceTimestamp to now\n lastRebalanceTimestamp = block.timestamp;\n\n // Save combined token arrays to failedAuctionWithdrawComponents\n failedAuctionWithdrawComponents = biddingParameters.combinedTokenArray;\n\n // Clear auction state\n clearAuctionState();\n }\n\n /*\n * Get token inflows and outflows required for bid. Also the amount of Rebalancing\n * Sets that would be generated.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function getBidPrice(\n uint256 _quantity\n )\n public\n view\n returns (uint256[] memory, uint256[] memory)\n {\n return PlaceBidLibrary.getBidPrice(\n _quantity,\n auctionLibrary,\n biddingParameters,\n auctionPriceParameters,\n uint8(rebalanceState)\n );\n }\n\n /*\n * Mint set token for given address.\n * Can only be called by Core contract.\n *\n * @param _issuer The address of the issuing account\n * @param _quantity The number of sets to attribute to issuer\n */\n function mint(\n address _issuer,\n uint256 _quantity\n )\n external\n {\n // Check that function caller is Core\n require(\n msg.sender == core,\n \"RebalancingSetToken.mint: Sender must be core\"\n );\n\n // Check that set is not in Rebalance State\n require(\n rebalanceState != RebalancingLibrary.State.Rebalance,\n \"RebalancingSetToken.mint: Cannot mint during Rebalance\"\n );\n\n // Check that set is not in Drawdown State\n require(\n rebalanceState != RebalancingLibrary.State.Drawdown,\n \"RebalancingSetToken.mint: Cannot mint during Drawdown\"\n );\n\n // Update token balance of the manager\n _mint(_issuer, _quantity);\n }\n\n /*\n * Burn set token for given address.\n * Can only be called by authorized contracts.\n *\n * @param _from The address of the redeeming account\n * @param _quantity The number of sets to burn from redeemer\n */\n function burn(\n address _from,\n uint256 _quantity\n )\n external\n {\n // Check that set is not in Rebalancing State\n require(\n rebalanceState != RebalancingLibrary.State.Rebalance,\n \"RebalancingSetToken.burn: Cannot burn during Rebalance\"\n );\n\n // Check to see if state is Drawdown\n if (rebalanceState == RebalancingLibrary.State.Drawdown) {\n // In Drawdown Sets can only be burned as part of the withdrawal process\n require(\n coreInstance.validModules(msg.sender),\n \"RebalancingSetToken.burn: Set cannot be redeemed during Drawdown\"\n );\n } else {\n // When in non-Rebalance or Drawdown state, check that function caller is Core\n // so that Sets can be redeemed\n require(\n msg.sender == core,\n \"RebalancingSetToken.burn: Sender must be core\"\n );\n }\n\n _burn(_from, _quantity);\n }\n\n /*\n * Set new manager address\n *\n * @param _newManager The address of the new manager account\n */\n function setManager(\n address _newManager\n )\n external\n {\n require(\n msg.sender == manager,\n \"RebalancingSetToken.setManager: Sender must be the manager\"\n );\n\n emit NewManagerAdded(_newManager, manager);\n manager = _newManager;\n }\n\n /* ============ Getter Functions ============ */\n\n /*\n * Get addresses of setToken underlying the Rebalancing Set\n *\n * @return componentAddresses Array of currentSet\n */\n function getComponents()\n external\n view\n returns (address[] memory)\n {\n address[] memory components = new address[](1);\n components[0] = currentSet;\n return components;\n }\n\n /*\n * Get unitShares of Rebalancing Set\n *\n * @return units Array of component unit\n */\n function getUnits()\n external\n view\n returns (uint256[] memory)\n {\n uint256[] memory units = new uint256[](1);\n units[0] = unitShares;\n return units;\n }\n\n /*\n * Get biddingParameters of Rebalancing Set\n *\n * @return biddingParams Object with bidding information\n */\n function getBiddingParameters()\n external\n view\n returns (uint256[] memory)\n {\n uint256[] memory biddingParams = new uint256[](2);\n biddingParams[0] = biddingParameters.minimumBid;\n biddingParams[1] = biddingParameters.remainingCurrentSets;\n return biddingParams;\n }\n\n /*\n * Get auctionPriceParameters of Rebalancing Set\n *\n * @return auctionParams Object with auction information\n */\n function getAuctionPriceParameters()\n external\n view\n returns (uint256[] memory)\n {\n uint256[] memory auctionParams = new uint256[](4);\n auctionParams[0] = auctionPriceParameters.auctionStartTime;\n auctionParams[1] = auctionPriceParameters.auctionTimeToPivot;\n auctionParams[2] = auctionPriceParameters.auctionStartPrice;\n auctionParams[3] = auctionPriceParameters.auctionPivotPrice;\n return auctionParams;\n }\n\n /*\n * Checks to make sure address is the current set of the RebalancingSetToken.\n * Conforms to the ISetToken Interface.\n *\n * @param _tokenAddress Address of token being checked\n * @return bool True if token is the current Set\n */\n function tokenIsComponent(\n address _tokenAddress\n )\n external\n view\n returns (bool)\n {\n return _tokenAddress == currentSet;\n }\n\n /*\n * Get combinedTokenArray of Rebalancing Set\n *\n * @return combinedTokenArray\n */\n function getCombinedTokenArrayLength()\n external\n view\n returns (uint256)\n {\n return biddingParameters.combinedTokenArray.length;\n }\n\n /*\n * Get combinedTokenArray of Rebalancing Set\n *\n * @return combinedTokenArray\n */\n function getCombinedTokenArray()\n external\n view\n returns (address[] memory)\n {\n return biddingParameters.combinedTokenArray;\n }\n\n /*\n * Get combinedCurrentUnits of Rebalancing Set\n *\n * @return combinedCurrentUnits\n */\n function getCombinedCurrentUnits()\n external\n view\n returns (uint256[] memory)\n {\n return biddingParameters.combinedCurrentUnits;\n }\n\n /*\n * Get combinedNextSetUnits of Rebalancing Set\n *\n * @return combinedNextSetUnits\n */\n function getCombinedNextSetUnits()\n external\n view\n returns (uint256[] memory)\n {\n return biddingParameters.combinedNextSetUnits;\n }\n\n /*\n * Get failedAuctionWithdrawComponents of Rebalancing Set\n *\n * @return failedAuctionWithdrawComponents\n */\n function getFailedAuctionWithdrawComponents()\n external\n view\n returns (address[] memory)\n {\n return failedAuctionWithdrawComponents;\n }\n\n /* ============ Internal Functions ============ */\n\n /*\n * Reset auction specific state after failed or successful rebalance\n */\n function clearAuctionState()\n internal\n {\n nextSet = address(0);\n auctionLibrary = address(0);\n startingCurrentSetAmount = 0;\n delete auctionPriceParameters;\n delete biddingParameters;\n }\n}\n"
},
{
"path": "contracts/core/tokens/RebalancingSetTokenFactory.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Bytes32Library } from \"set-protocol-contract-utils/contracts/lib/Bytes32Library.sol\";\n\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { LibBytes } from \"../../external/0x/LibBytes.sol\";\nimport { RebalancingSetToken } from \"./RebalancingSetToken.sol\";\nimport { IWhiteList } from \"../interfaces/IWhiteList.sol\";\n\n\n/**\n * @title RebalancingSetTokenFactory\n * @author Set Protocol\n *\n * RebalancingSetTokenFactory is a smart contract used to deploy new RebalancingSetToken contracts.\n * RebalancingSetTokens deployed by the factory can only have their mint and burn functions\n * called by Core\n */\ncontract RebalancingSetTokenFactory {\n using LibBytes for bytes;\n using Bytes32Library for bytes32;\n\n /* ============ State Variables ============ */\n\n // Address of the Core contract used to verify factory when creating a Set\n address public core;\n\n // Address of the WhiteList contract used to verify the tokens in a rebalance proposal\n address public rebalanceComponentWhitelist;\n\n // Minimum amount of time between rebalances in seconds\n uint256 public minimumRebalanceInterval;\n\n // Minimum amount of time users can review proposals\n uint256 public minimumProposalPeriod;\n\n // Minimum amount of time before auction pivot can be reached\n uint256 public minimumTimeToPivot;\n\n // Maximum amount of time before auction pivot can be reached\n uint256 public maximumTimeToPivot;\n\n // Minimum number for the token natural unit\n // The bounds are used for calculations of unitShares and in settlement\n uint256 public minimumNaturalUnit;\n\n // Maximum number for the token natural unit\n uint256 public maximumNaturalUnit;\n\n // ============ Structs ============\n\n struct InitRebalancingParameters {\n address manager;\n uint256 proposalPeriod;\n uint256 rebalanceInterval;\n }\n\n /* ============ Constructor ============ */\n\n /**\n * Set core. Also requires a minimum rebalance interval and minimum proposal periods that are enforced\n * on RebalancingSetToken\n *\n * @param _core Address of deployed core contract\n * @param _componentWhitelist Address of deployed whitelist contract\n * @param _minimumRebalanceInterval Minimum amount of time between rebalances in seconds\n * @param _minimumProposalPeriod Minimum amount of time users can review proposals in seconds\n * @param _minimumTimeToPivot Minimum amount of time before auction pivot can be reached\n * @param _maximumTimeToPivot Maximum amount of time before auction pivot can be reached\n * @param _minimumNaturalUnit Minimum number for the token natural unit\n * @param _maximumNaturalUnit Maximum number for the token natural unit\n */\n constructor(\n address _core,\n address _componentWhitelist,\n uint256 _minimumRebalanceInterval,\n uint256 _minimumProposalPeriod,\n uint256 _minimumTimeToPivot,\n uint256 _maximumTimeToPivot,\n uint256 _minimumNaturalUnit,\n uint256 _maximumNaturalUnit\n )\n public\n {\n core = _core;\n rebalanceComponentWhitelist = _componentWhitelist;\n minimumRebalanceInterval = _minimumRebalanceInterval;\n minimumProposalPeriod = _minimumProposalPeriod;\n minimumTimeToPivot = _minimumTimeToPivot;\n maximumTimeToPivot = _maximumTimeToPivot;\n minimumNaturalUnit = _minimumNaturalUnit;\n maximumNaturalUnit = _maximumNaturalUnit;\n }\n\n /* ============ Public Functions ============ */\n\n /**\n * Deploys a new RebalancingSetToken contract, conforming to IFactory\n * Can only be called by core contracts.\n *\n *\n * | Data | Location |\n * |----------------------------|-------------------------------|\n * | manager | 32 |\n * | proposalPeriod | 64 |\n * | rebalanceInterval | 96 |\n *\n * @param _components The address of component tokens\n * @param _units The units of each component token\n * -- Unused natural unit parameters, passed in to conform to IFactory --\n * @param _name The bytes32 encoded name of the new RebalancingSetToken\n * @param _symbol The bytes32 encoded symbol of the new RebalancingSetToken\n * @param _callData Byte string containing additional call parameters\n * @return setToken The address of the newly created SetToken\n */\n function createSet(\n address[] calldata _components,\n uint256[] calldata _units,\n uint256 _naturalUnit,\n bytes32 _name,\n bytes32 _symbol,\n bytes calldata _callData\n )\n external\n returns (address)\n {\n // Expecting caller to be Core\n require(\n msg.sender == core,\n \"RebalancingSetTokenFactory.create: Sender must be core\"\n );\n\n // Ensure component array only includes one address which will be the currentSet\n require(\n _components.length == 1,\n \"RebalancingSetTokenFactory.create: Components must be length 1\"\n );\n\n // Ensure units array only includes one uint which will be the starting unitShares\n require(\n _units.length == 1,\n \"RebalancingSetTokenFactory.create: Units must be length 1\"\n );\n\n // Ensure unitShares is not set to 0\n require(\n _units[0] > 0,\n \"RebalancingSetTokenFactory.create: UnitShares must be greater than zero\"\n );\n\n // Retrieve address of initial Set for rebalancing token\n address startingSet = _components[0];\n\n // Expect Set to rebalance to be valid and enabled Set\n require(\n ICore(core).validSets(startingSet),\n \"RebalancingSetTokenFactory.create: Invalid or disabled SetToken address\"\n );\n\n // Parse _callData for additional parameters\n InitRebalancingParameters memory parameters = parseRebalanceSetCallData(\n _callData\n );\n\n // Create a new SetToken contract\n return address(\n new RebalancingSetToken(\n address(this),\n parameters.manager,\n startingSet,\n _units[0],\n _naturalUnit,\n parameters.proposalPeriod,\n parameters.rebalanceInterval,\n rebalanceComponentWhitelist,\n _name.bytes32ToString(),\n _symbol.bytes32ToString()\n )\n );\n }\n\n /* ============ Private Functions ============ */\n\n function parseRebalanceSetCallData(\n bytes memory _callData\n )\n private\n pure\n returns (InitRebalancingParameters memory)\n {\n InitRebalancingParameters memory parameters;\n\n assembly {\n mstore(parameters, mload(add(_callData, 32))) // manager\n mstore(add(parameters, 32), mload(add(_callData, 64))) // proposalPeriod\n mstore(add(parameters, 64), mload(add(_callData, 96))) // rebalanceInterval\n }\n\n return parameters;\n }\n}\n"
},
{
"path": "contracts/core/tokens/RebalancingSetTokenV2.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20 } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\nimport { ERC20Detailed } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol\";\nimport { Initializable } from \"zos-lib/contracts/Initializable.sol\";\n\nimport { BackwardCompatibility } from \"./rebalancing-v2/BackwardCompatibility.sol\";\nimport { RebalancingFailure } from \"./rebalancing-v2/RebalancingFailure.sol\";\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { IFeeCalculator } from \"../interfaces/IFeeCalculator.sol\";\nimport { ILiquidator } from \"../interfaces/ILiquidator.sol\";\nimport { IRebalancingSetFactory } from \"../interfaces/IRebalancingSetFactory.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { Issuance } from \"./rebalancing-v2/Issuance.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\nimport { IWhiteList } from \"../interfaces/IWhiteList.sol\";\nimport { RebalancingBid } from \"./rebalancing-v2/RebalancingBid.sol\";\nimport { Rebalance } from \"../lib/Rebalance.sol\";\nimport { RebalancingLibrary } from \"../lib/RebalancingLibrary.sol\";\nimport { RebalancingSetState } from \"./rebalancing-v2/RebalancingSetState.sol\";\nimport { RebalancingSettlement } from \"./rebalancing-v2/RebalancingSettlement.sol\";\nimport { RebalancingStart } from \"./rebalancing-v2/RebalancingStart.sol\";\n\n\n/**\n * @title RebalancingSetTokenV2\n * @author Set Protocol\n *\n * Implementation of Rebalancing Set token V2. Major improvements vs. V1 include:\n * - Decouple the Rebalancing Set state and rebalance state from the rebalance execution (e.g. auction)\n * This allows us to rapidly iterate and build new liquidation mechanisms for rebalances.\n * - Proposals are removed in favor of starting an auction directly.\n * - The Set retains ability to fail an auction if the minimum fail time has elapsed.\n * - RebalanceAuctionModule execution should be backwards compatible with V1. \n * - Bidding and auction parameters state no longer live on this contract. They live on the liquidator\n * BackwardsComptability is used to allow retrieving of previous supported states.\n * - Introduces entry and rebalance fees, where rebalance fees are configurable based on an external\n * fee calculator contract\n */\ncontract RebalancingSetTokenV2 is\n ERC20,\n ERC20Detailed,\n Initializable,\n RebalancingSetState,\n BackwardCompatibility,\n Issuance,\n RebalancingStart,\n RebalancingBid,\n RebalancingSettlement,\n RebalancingFailure\n{\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for Rebalancing Set Token\n *\n * addressConfig [factory, manager, liquidator, initialSet, componentWhiteList, \n * liquidatorWhiteList, feeRecipient, rebalanceFeeCalculator]\n * [0]factory Factory used to create the Rebalancing Set\n * [1]manager Address that is able to propose the next Set\n * [2]liquidator Address of the liquidator contract\n * [3]initialSet Initial set that collateralizes the Rebalancing set\n * [4]componentWhiteList Whitelist that nextSet components are checked against during propose\n * [5]liquidatorWhiteList Whitelist of valid liquidators\n * [6]feeRecipient Address that receives any incentive fees\n * [7]rebalanceFeeCalculator Address to retrieve rebalance fee during settlement\n *\n * uintConfig [initialUnitShares, naturalUnit, rebalanceInterval, rebalanceFailPeriod, \n * lastRebalanceTimestamp, entryFee]\n * [0]initialUnitShares Units of currentSet that equals one share\n * [1]naturalUnit The minimum multiple of Sets that can be issued or redeemed\n * [2]rebalanceInterval: Minimum amount of time between rebalances\n * [3]rebalanceFailPeriod: Time after auctionStart where something in the rebalance has gone wrong\n * [4]lastRebalanceTimestamp: Time of the last rebalance; Allows customized deployments\n * [5]entryFee: Mint fee represented in a scaled decimal value (e.g. 100% = 1e18, 1% = 1e16)\n *\n * @param _addressConfig List of configuration addresses\n * @param _uintConfig List of uint addresses\n * @param _name The name of the new RebalancingSetTokenV2\n * @param _symbol The symbol of the new RebalancingSetTokenV2\n */\n constructor(\n address[8] memory _addressConfig,\n uint256[6] memory _uintConfig,\n string memory _name,\n string memory _symbol\n )\n public\n ERC20Detailed(\n _name,\n _symbol,\n 18\n )\n {\n factory = IRebalancingSetFactory(_addressConfig[0]);\n manager = _addressConfig[1];\n liquidator = ILiquidator(_addressConfig[2]);\n currentSet = ISetToken(_addressConfig[3]);\n componentWhiteList = IWhiteList(_addressConfig[4]);\n liquidatorWhiteList = IWhiteList(_addressConfig[5]);\n feeRecipient = _addressConfig[6];\n rebalanceFeeCalculator = IFeeCalculator(_addressConfig[7]);\n\n unitShares = _uintConfig[0];\n naturalUnit = _uintConfig[1];\n rebalanceInterval = _uintConfig[2];\n rebalanceFailPeriod = _uintConfig[3];\n lastRebalanceTimestamp = _uintConfig[4];\n entryFee = _uintConfig[5];\n\n core = ICore(factory.core());\n vault = IVault(core.vault());\n rebalanceState = RebalancingLibrary.State.Default;\n }\n\n /*\n * Intended to be called during creation by the RebalancingSetTokenFactory. Can only be initialized\n * once. This implementation initializes the rebalance fee.\n *\n *\n * @param _rebalanceFeeCalldata Bytes encoded rebalance fee represented as a scaled percentage value\n */\n function initialize(\n bytes calldata _rebalanceFeeCalldata\n )\n external\n initializer\n {\n rebalanceFeeCalculator.initialize(_rebalanceFeeCalldata);\n }\n\n /* ============ External Functions ============ */\n\n /*\n * Initiates the rebalance in coordination with the Liquidator contract. \n * In this step, we redeem the currentSet and pass relevant information\n * to the liquidator.\n *\n * @param _nextSet The Set to rebalance into\n * @param _liquidatorData Bytecode formatted data with liquidator-specific arguments\n *\n * Can only be called if the rebalance interval has elapsed.\n * Can only be called by manager.\n */\n function startRebalance(\n ISetToken _nextSet,\n bytes calldata _liquidatorData\n )\n external\n onlyManager\n {\n RebalancingStart.validateStartRebalance(_nextSet);\n\n uint256 startingCurrentSetQuantity = RebalancingStart.calculateStartingSetQuantity();\n\n core.redeemInVault(address(currentSet), startingCurrentSetQuantity);\n\n RebalancingStart.liquidatorRebalancingStart(_nextSet, startingCurrentSetQuantity, _liquidatorData);\n\n RebalancingStart.transitionToRebalance(_nextSet);\n\n emit RebalanceStarted(\n address(currentSet),\n address(nextSet),\n rebalanceIndex,\n startingCurrentSetQuantity\n );\n }\n\n /*\n * Get token inflows and outflows required for bid from the Liquidator.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function getBidPrice(\n uint256 _quantity\n )\n public\n view\n returns (uint256[] memory, uint256[] memory)\n {\n RebalancingBid.validateGetBidPrice(_quantity);\n\n return Rebalance.decomposeTokenFlowToBidPrice(\n liquidator.getBidPrice(address(this), _quantity)\n );\n }\n\n /*\n * Place bid during rebalance auction. \n * \n * The intended caller is the RebalanceAuctionModule, which must be approved by Core.\n * Call Flow:\n * RebalanceAuctionModule -> RebalancingSetTokenV2 -> Liquidator\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @return combinedTokenArray Array of token addresses invovled in rebalancing\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function placeBid(\n uint256 _quantity\n )\n external\n returns (address[] memory, uint256[] memory, uint256[] memory)\n {\n RebalancingBid.validatePlaceBid(_quantity);\n\n // Place bid and get back inflow and outflow arrays\n Rebalance.TokenFlow memory tokenFlow = liquidator.placeBid(_quantity);\n\n RebalancingBid.updateHasBiddedIfNecessary();\n\n return Rebalance.decomposeTokenFlow(tokenFlow);\n }\n\n /*\n * After a successful rebalance, the new Set is issued. If there is a rebalance fee,\n * the fee is paid via inflation of the Rebalancing Set to the feeRecipient.\n * Full issuance functionality is now returned to set owners.\n *\n * Anyone can call this function.\n */\n function settleRebalance()\n external\n {\n RebalancingSettlement.validateRebalancingSettlement();\n\n uint256 issueQuantity = RebalancingSettlement.calculateSetIssueQuantity(nextSet);\n\n // Calculates fees and mints Rebalancing Set to the feeRecipient, increasing supply\n (uint256 feePercent, uint256 feeQuantity) = RebalancingSettlement.handleFees();\n\n uint256 newUnitShares = RebalancingSettlement.calculateNextSetNewUnitShares(issueQuantity);\n\n // The unit shares must result in a quantity greater than the number of natural units outstanding\n require(\n newUnitShares > 0,\n \"Failed: unitshares is 0.\"\n );\n\n RebalancingSettlement.issueNextSet(issueQuantity);\n\n liquidator.settleRebalance();\n\n // Rebalance index is the current vs next rebalance\n emit RebalanceSettled(\n feeRecipient,\n feeQuantity,\n feePercent,\n rebalanceIndex,\n issueQuantity,\n newUnitShares\n );\n\n RebalancingSettlement.transitionToDefault(newUnitShares);\n\n }\n\n /*\n * Ends a rebalance if there are any signs that there is a failure. \n * Possible failure reasons:\n * 1. The rebalance has elapsed the failRebalancePeriod\n * 2. The liquidator responds that the rebalance has failed\n * \n * Move to Drawdown state if bids have been placed. Reset to Default state if no bids placed.\n */\n function endFailedRebalance()\n public\n {\n RebalancingFailure.validateFailRebalance();\n\n RebalancingLibrary.State newRebalanceState = RebalancingFailure.getNewRebalanceState();\n\n liquidator.endFailedRebalance();\n\n RebalancingFailure.transitionToNewState(newRebalanceState);\n }\n\n /*\n * Mint set token for given address. If there if is an entryFee, calculates the fee and mints\n * the rebalancing SetToken to the feeRecipient.\n * \n * Can only be called by Core contract.\n *\n * @param _issuer The address of the issuing account\n * @param _quantity The number of sets to attribute to issuer\n */\n function mint(\n address _issuer,\n uint256 _quantity\n )\n external\n {\n Issuance.validateMint();\n\n uint256 issueQuantityNetOfFees = Issuance.handleEntryFees(_quantity);\n\n ERC20._mint(_issuer, issueQuantityNetOfFees);\n }\n\n /*\n * Burn set token for given address. Can only be called by authorized contracts.\n *\n * @param _from The address of the redeeming account\n * @param _quantity The number of sets to burn from redeemer\n */\n function burn(\n address _from,\n uint256 _quantity\n )\n external\n {\n Issuance.validateBurn();\n\n ERC20._burn(_from, _quantity);\n }\n\n /* ============ Backwards Compatability ============ */\n\n /*\n * Alias for endFailedRebalance\n */\n function endFailedAuction() external {\n endFailedRebalance();\n }\n}\n"
},
{
"path": "contracts/core/tokens/RebalancingSetTokenV2Factory.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Bytes32Library } from \"set-protocol-contract-utils/contracts/lib/Bytes32Library.sol\";\n\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { ILiquidator } from \"../interfaces/ILiquidator.sol\";\nimport { IRebalancingSetTokenV2 } from \"../interfaces/IRebalancingSetTokenV2.sol\";\nimport { LibBytes } from \"../../external/0x/LibBytes.sol\";\nimport { RebalancingSetTokenV2 } from \"./RebalancingSetTokenV2.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { IWhiteList } from \"../interfaces/IWhiteList.sol\";\n\n\n/**\n * @title RebalancingSetTokenV2Factory\n * @author Set Protocol\n *\n * RebalancingSetTokenV2Factory is a smart contract used to deploy new RebalancingSetTokenV2 contracts.\n * RebalancingSetTokenV2s deployed by the factory can only have their mint and burn functions\n * called by Core\n */\ncontract RebalancingSetTokenV2Factory {\n using LibBytes for bytes;\n using Bytes32Library for bytes32;\n\n /* ============ State Variables ============ */\n\n // Address of the Core contract used to verify factory when creating a Set\n ICore public core;\n\n // Address of the WhiteList contract used to verify the tokens in a rebalance proposal\n IWhiteList public rebalanceComponentWhitelist;\n\n // Whitelist contract for approved liquidators\n IWhiteList public liquidatorWhitelist;\n\n // Whitelist contract for approved fee calcualtors\n IWhiteList public feeCalculatorWhitelist;\n\n // Minimum amount of time between rebalances in seconds\n uint256 public minimumRebalanceInterval;\n\n // Minimum fail auction period\n uint256 public minimumFailRebalancePeriod;\n\n // Maximum fail auction period\n uint256 public maximumFailRebalancePeriod;\n\n // Minimum number for the token natural unit\n // The bounds are used for calculations of unitShares and in settlement\n uint256 public minimumNaturalUnit;\n\n // Maximum number for the token natural unit\n uint256 public maximumNaturalUnit;\n\n // ============ Structs ============\n\n struct InitRebalancingParameters {\n address manager;\n ILiquidator liquidator;\n address feeRecipient;\n address rebalanceFeeCalculator;\n uint256 rebalanceInterval;\n uint256 rebalanceFailPeriod;\n uint256 lastRebalanceTimestamp;\n uint256 entryFee;\n bytes rebalanceFeeCalculatorData;\n }\n\n /* ============ Constructor ============ */\n\n /**\n * Set core. Also requires a minimum rebalance interval and minimum proposal periods that are enforced\n * on RebalancingSetTokenV2\n *\n * @param _core Address of deployed core contract\n * @param _componentWhitelist Address of component whitelist contract\n * @param _liquidatorWhitelist Address of liquidator whitelist contract\n * @param _feeCalculatorWhitelist Address of feeCalculator whitelist contract\n * @param _minimumRebalanceInterval Minimum amount of time between rebalances in seconds\n * @param _minimumNaturalUnit Minimum number for the token natural unit\n * @param _maximumNaturalUnit Maximum number for the token natural unit\n */\n constructor(\n ICore _core,\n IWhiteList _componentWhitelist,\n IWhiteList _liquidatorWhitelist,\n IWhiteList _feeCalculatorWhitelist,\n uint256 _minimumRebalanceInterval,\n uint256 _minimumFailRebalancePeriod,\n uint256 _maximumFailRebalancePeriod,\n uint256 _minimumNaturalUnit,\n uint256 _maximumNaturalUnit\n )\n public\n {\n core = _core;\n rebalanceComponentWhitelist = _componentWhitelist;\n liquidatorWhitelist = _liquidatorWhitelist;\n feeCalculatorWhitelist = _feeCalculatorWhitelist;\n minimumRebalanceInterval = _minimumRebalanceInterval;\n minimumFailRebalancePeriod = _minimumFailRebalancePeriod;\n maximumFailRebalancePeriod = _maximumFailRebalancePeriod;\n minimumNaturalUnit = _minimumNaturalUnit;\n maximumNaturalUnit = _maximumNaturalUnit;\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Deploys a new RebalancingSetTokenV2 contract, conforming to IFactory\n * Can only be called by core contracts.\n *\n * \n * | CallData | Location |\n * |----------------------------|-------------------------------|\n * | manager | 32 |\n * | liquidator | 64 |\n * | feeRecipient | 96 |\n * | rebalanceFeeCalculator | 128 |\n * | rebalanceInterval | 160 |\n * | rebalanceFailPeriod | 192 |\n * | entryFee | 224 |\n * | rebalanceFeeCalculatorData | 256 to end |\n *\n * @param _components The address of component tokens\n * @param _units The units of each component token\n * -- Unused natural unit parameters, passed in to conform to IFactory --\n * @param _name The bytes32 encoded name of the new RebalancingSetTokenV2\n * @param _symbol The bytes32 encoded symbol of the new RebalancingSetTokenV2\n * @param _callData Byte string containing additional call parameters\n * \n * @return setToken The address of the newly created SetToken\n */\n function createSet(\n address[] calldata _components,\n uint256[] calldata _units,\n uint256 _naturalUnit,\n bytes32 _name,\n bytes32 _symbol,\n bytes calldata _callData\n )\n external\n returns (address)\n {\n require(\n msg.sender == address(core),\n \"Sender must be core\"\n );\n\n // Ensure component array only includes one address which will be the currentSet\n require(\n _components.length == 1 && \n _units.length == 1,\n \"Components & units must be len 1\"\n );\n\n require(\n _units[0] > 0,\n \"UnitShares not > 0\"\n );\n\n address startingSet = _components[0];\n\n // Expect Set to rebalance to be valid and enabled Set\n require(\n core.validSets(startingSet),\n \"Invalid SetToken\"\n );\n\n require(\n _naturalUnit >= minimumNaturalUnit && _naturalUnit <= maximumNaturalUnit,\n \"Invalid natural unit\"\n );\n\n InitRebalancingParameters memory parameters = parseRebalanceSetCallData(_callData);\n\n require(\n parameters.manager != address(0),\n \"Invalid manager\"\n );\n\n // Require liquidator address is non-zero and is whitelisted by the liquidatorWhitelist\n require(\n address(parameters.liquidator) != address(0) && \n liquidatorWhitelist.whiteList(address(parameters.liquidator)),\n \"Invalid liquidator\"\n );\n\n // Require rebalance fee is whitelisted by the liquidatorWhitelist\n require(\n feeCalculatorWhitelist.whiteList(address(parameters.rebalanceFeeCalculator)),\n \"Invalid fee calculator\"\n );\n\n require(\n parameters.rebalanceInterval >= minimumRebalanceInterval,\n \"Rebalance interval too short\"\n ); \n\n require(\n parameters.rebalanceFailPeriod >= minimumFailRebalancePeriod &&\n parameters.rebalanceFailPeriod <= maximumFailRebalancePeriod,\n \"Invalid Fail Period\"\n );\n\n require(\n parameters.lastRebalanceTimestamp <= block.timestamp,\n \"Invalid RebalanceTimestamp\"\n );\n\n address rebalancingSet = address(\n new RebalancingSetTokenV2(\n [\n address(this), // factory\n parameters.manager, // manager\n address(parameters.liquidator), // liquidator\n startingSet, // initialSet\n address(rebalanceComponentWhitelist), // componentWhiteList\n address(liquidatorWhitelist), // liquidatorWhiteList\n parameters.feeRecipient, // feeRecipient\n parameters.rebalanceFeeCalculator // rebalanceFeeCalculator\n ],\n [\n _units[0], // unitShares\n _naturalUnit, // naturalUnit\n parameters.rebalanceInterval, // rebalanceInterval\n parameters.rebalanceFailPeriod, // rebalanceFailPeriod\n parameters.lastRebalanceTimestamp, // lastRebalanceTimestamp\n parameters.entryFee // entryFee\n ],\n _name.bytes32ToString(),\n _symbol.bytes32ToString()\n )\n );\n\n // Initializes the RebalancingSetToken\n IRebalancingSetTokenV2(rebalancingSet).initialize(parameters.rebalanceFeeCalculatorData);\n\n return rebalancingSet;\n }\n\n /* ============ Private Functions ============ */\n\n function parseRebalanceSetCallData(\n bytes memory _callData\n )\n private\n pure\n returns (InitRebalancingParameters memory)\n {\n InitRebalancingParameters memory parameters;\n\n assembly {\n mstore(parameters, mload(add(_callData, 32))) // manager\n mstore(add(parameters, 32), mload(add(_callData, 64))) // liquidator\n mstore(add(parameters, 64), mload(add(_callData, 96))) // feeRecipient\n mstore(add(parameters, 96), mload(add(_callData, 128))) // rebalanceFeeCalculator\n mstore(add(parameters, 128), mload(add(_callData, 160))) // rebalanceInterval\n mstore(add(parameters, 160), mload(add(_callData, 192))) // rebalanceFailPeriod\n mstore(add(parameters, 192), mload(add(_callData, 224))) // lastRebalanceTimestamp\n mstore(add(parameters, 224), mload(add(_callData, 256))) // entryFee\n }\n\n // Extracts the fee calculator data from the remaining calldata\n parameters.rebalanceFeeCalculatorData = _callData.slice(256, _callData.length);\n\n return parameters;\n }\n}\n"
},
{
"path": "contracts/core/tokens/RebalancingSetTokenV3.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { IncentiveFee } from \"./rebalancing-v3/IncentiveFee.sol\";\nimport { RebalancingSettlement } from \"./rebalancing-v2/RebalancingSettlement.sol\";\nimport { RebalancingSetTokenV2 } from \"./RebalancingSetTokenV2.sol\";\n\n\n/**\n * @title RebalancingSetTokenV3\n * @author Set Protocol\n *\n * Implementation of Rebalancing Set token V2. Major improvements vs. V2 include:\n * - Separating incentive fees from the settlement process.\n */\ncontract RebalancingSetTokenV3 is\n IncentiveFee,\n RebalancingSetTokenV2\n{\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for Rebalancing Set Token\n *\n * addressConfig [factory, manager, liquidator, initialSet, componentWhiteList,\n * liquidatorWhiteList, feeRecipient, rebalanceFeeCalculator]\n * [0]factory Factory used to create the Rebalancing Set\n * [1]manager Address that is able to propose the next Set\n * [2]liquidator Address of the liquidator contract\n * [3]initialSet Initial set that collateralizes the Rebalancing set\n * [4]componentWhiteList Whitelist that nextSet components are checked against during propose\n * [5]liquidatorWhiteList Whitelist of valid liquidators\n * [6]feeRecipient Address that receives any incentive fees\n * [7]rebalanceFeeCalculator Address to retrieve rebalance fee during settlement\n *\n * uintConfig [initialUnitShares, naturalUnit, rebalanceInterval, rebalanceFailPeriod,\n * lastRebalanceTimestamp, entryFee]\n * [0]initialUnitShares Units of currentSet that equals one share\n * [1]naturalUnit The minimum multiple of Sets that can be issued or redeemed\n * [2]rebalanceInterval: Minimum amount of time between rebalances\n * [3]rebalanceFailPeriod: Time after auctionStart where something in the rebalance has gone wrong\n * [4]lastRebalanceTimestamp: Time of the last rebalance; Allows customized deployments\n * [5]entryFee: Mint fee represented in a scaled decimal value (e.g. 100% = 1e18, 1% = 1e16)\n *\n * @param _addressConfig List of configuration addresses\n * @param _uintConfig List of uint addresses\n * @param _name The name of the new RebalancingSetTokenV2\n * @param _symbol The symbol of the new RebalancingSetTokenV2\n */\n constructor(\n address[8] memory _addressConfig,\n uint256[6] memory _uintConfig,\n string memory _name,\n string memory _symbol\n )\n public\n RebalancingSetTokenV2(\n _addressConfig,\n _uintConfig,\n _name,\n _symbol\n )\n {}\n\n /*\n * Overrides the RebalancingSetTokenV2 settleRebalance function.\n *\n * After a successful rebalance, the new Set is issued.\n * Full issuance functionality is now returned to set owners. No fees are captured.\n *\n * Anyone can call this function.\n */\n function settleRebalance()\n external\n {\n // It can only be callable in the Default state\n RebalancingSettlement.validateRebalancingSettlement();\n\n uint256 issueQuantity = RebalancingSettlement.calculateSetIssueQuantity(nextSet);\n uint256 newUnitShares = RebalancingSettlement.calculateNextSetNewUnitShares(issueQuantity);\n\n validateUnitShares(newUnitShares);\n\n RebalancingSettlement.issueNextSet(issueQuantity);\n\n liquidator.settleRebalance();\n\n emit RebalanceSettled(\n address(0), // No longer used\n 0, // No longer used\n 0, // No longer used\n rebalanceIndex, // Current Rebalance index\n issueQuantity,\n newUnitShares\n );\n\n RebalancingSettlement.transitionToDefault(newUnitShares);\n }\n\n /*\n * During the Default stage, the incentive / rebalance Fee can be triggered. This will\n * retrieve the current inflation fee from the fee calulator and mint the according\n * inflation to the feeRecipient. The unit shares is then adjusted based on the new\n * supply.\n *\n * Anyone can call this function.\n */\n function actualizeFee()\n public\n {\n IncentiveFee.validateFeeActualization();\n\n // Calculates fees and mints Rebalancing Set to the feeRecipient, increasing supply\n (uint256 feePercent, uint256 feeQuantity) = IncentiveFee.handleFees();\n\n // The minting of new supply changes the unit Shares\n uint256 newUnitShares = IncentiveFee.calculateNewUnitShares();\n\n validateUnitShares(newUnitShares);\n\n // Set the new unit shares\n unitShares = newUnitShares;\n\n // Emit IncentiveFeePaid event\n emit IncentiveFeePaid(\n feeRecipient,\n feeQuantity,\n feePercent,\n newUnitShares\n );\n }\n\n /*\n * Accrue any fees then adjust fee parameters on feeCalculator. Only callable by manager.\n *\n * @param _newFeeData Fee type and new streaming fee encoded in bytes\n */\n function adjustFee(\n bytes calldata _newFeeData\n )\n external\n onlyManager\n {\n actualizeFee();\n\n rebalanceFeeCalculator.adjustFee(_newFeeData);\n }\n\n /* ============ V3 Internal Functions ============ */\n\n /*\n * The unit shares must result in a quantity greater than the number of natural units outstanding.\n * In other words, it must be greater than 0\n */\n function validateUnitShares(uint256 _newUnitShares) internal view {\n require(\n _newUnitShares > 0,\n \"Unitshares is 0\"\n );\n }\n}\n"
},
{
"path": "contracts/core/tokens/RebalancingSetTokenV3Factory.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Bytes32Library } from \"set-protocol-contract-utils/contracts/lib/Bytes32Library.sol\";\n\nimport { FactoryUtilsLibrary } from \"./rebalancing-v3/FactoryUtilsLibrary.sol\";\nimport { ICore } from \"../interfaces/ICore.sol\";\nimport { ILiquidator } from \"../interfaces/ILiquidator.sol\";\nimport { IRebalancingSetTokenV2 } from \"../interfaces/IRebalancingSetTokenV2.sol\";\nimport { ISetToken } from \"../interfaces/ISetToken.sol\";\nimport { IWhiteList } from \"../interfaces/IWhiteList.sol\";\nimport { LibBytes } from \"../../external/0x/LibBytes.sol\";\nimport { RebalancingSetTokenV2Factory } from \"./RebalancingSetTokenV2Factory.sol\";\nimport { RebalancingSetTokenV3 } from \"./RebalancingSetTokenV3.sol\";\nimport { SetTokenLibrary } from \"../lib/SetTokenLibrary.sol\";\n\n\n/**\n * @title RebalancingSetTokenV3Factory\n * @author Set Protocol\n *\n * RebalancingSetTokenV3Factory is a smart contract used to deploy new RebalancingSetTokenV3 contracts.\n */\ncontract RebalancingSetTokenV3Factory is RebalancingSetTokenV2Factory {\n\n /* ============ Constructor ============ */\n\n /**\n *\n * @param _core Address of deployed core contract\n * @param _componentWhitelist Address of component whitelist contract\n * @param _liquidatorWhitelist Address of liquidator whitelist contract\n * @param _feeCalculatorWhitelist Address of feeCalculator whitelist contract\n * @param _minimumRebalanceInterval Minimum amount of time between rebalances in seconds\n * @param _minimumNaturalUnit Minimum number for the token natural unit\n * @param _maximumNaturalUnit Maximum number for the token natural unit\n */\n constructor(\n ICore _core,\n IWhiteList _componentWhitelist,\n IWhiteList _liquidatorWhitelist,\n IWhiteList _feeCalculatorWhitelist,\n uint256 _minimumRebalanceInterval,\n uint256 _minimumFailRebalancePeriod,\n uint256 _maximumFailRebalancePeriod,\n uint256 _minimumNaturalUnit,\n uint256 _maximumNaturalUnit\n )\n public\n RebalancingSetTokenV2Factory(\n _core,\n _componentWhitelist,\n _liquidatorWhitelist,\n _feeCalculatorWhitelist,\n _minimumRebalanceInterval,\n _minimumFailRebalancePeriod,\n _maximumFailRebalancePeriod,\n _minimumNaturalUnit,\n _maximumNaturalUnit\n )\n {}\n\n /* ============ External Functions ============ */\n\n /**\n * Overrides the RebalancingSetTokenV2Factory createSet function.\n *\n * Deploys a new RebalancingSetTokenV3 contract, conforming to IFactory\n * Can only be called by core contracts.\n *\n *\n * | CallData | Location |\n * |----------------------------|-------------------------------|\n * | manager | 32 |\n * | liquidator | 64 |\n * | feeRecipient | 96 |\n * | rebalanceFeeCalculator | 128 |\n * | rebalanceInterval | 160 |\n * | rebalanceFailPeriod | 192 |\n * | entryFee | 224 |\n * | rebalanceFeeCalculatorData | 256 to end |\n *\n * @param _components The address of component tokens\n * @param _units The units of each component token\n * @param _naturalUnit Minimum issuable amount of the RebalancingSetTokenV3\n * @param _name The bytes32 encoded name of the new RebalancingSetTokenV3\n * @param _symbol The bytes32 encoded symbol of the new RebalancingSetTokenV3\n * @param _callData Byte string containing additional call parameters\n *\n * @return setToken The address of the newly created SetToken\n */\n function createSet(\n address[] calldata _components,\n uint256[] calldata _units,\n uint256 _naturalUnit,\n bytes32 _name,\n bytes32 _symbol,\n bytes calldata _callData\n )\n external\n returns (address)\n {\n SetTokenLibrary.SetDetails memory rebalancingSetDetails = SetTokenLibrary.SetDetails({\n naturalUnit: _naturalUnit,\n components: _components,\n units: _units\n });\n\n FactoryUtilsLibrary.validateRebalancingSet(\n rebalancingSetDetails,\n address(core),\n msg.sender,\n minimumNaturalUnit,\n maximumNaturalUnit\n );\n\n // Parse the calldata\n FactoryUtilsLibrary.InitRebalancingParameters memory parameters =\n FactoryUtilsLibrary.parseRebalanceSetCallData(_callData);\n\n // Ensure validity of rebalancing Set calldata\n FactoryUtilsLibrary.validateRebalanceSetCalldata(\n parameters,\n address(liquidatorWhitelist),\n address(feeCalculatorWhitelist),\n minimumRebalanceInterval,\n minimumFailRebalancePeriod,\n maximumFailRebalancePeriod\n );\n\n address rebalancingSet = address(\n new RebalancingSetTokenV3(\n [\n address(this), // factory\n parameters.manager, // manager\n parameters.liquidator, // liquidator\n _components[0], // initialSet\n address(rebalanceComponentWhitelist), // componentWhiteList\n address(liquidatorWhitelist), // liquidatorWhiteList\n parameters.feeRecipient, // feeRecipient\n parameters.rebalanceFeeCalculator // rebalanceFeeCalculator\n ],\n [\n _units[0], // unitShares\n _naturalUnit, // naturalUnit\n parameters.rebalanceInterval, // rebalanceInterval\n parameters.rebalanceFailPeriod, // rebalanceFailPeriod\n parameters.lastRebalanceTimestamp, // lastRebalanceTimestamp\n parameters.entryFee // entryFee\n ],\n _name.bytes32ToString(),\n _symbol.bytes32ToString()\n )\n );\n\n // Initializes the RebalancingSetToken using the V2 interface (as the interface has not changed)\n IRebalancingSetTokenV2(rebalancingSet).initialize(parameters.rebalanceFeeCalculatorData);\n\n return rebalancingSet;\n }\n}\n"
},
{
"path": "contracts/core/tokens/SetToken.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\nimport { ERC20Detailed } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { ERC20 } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\nimport { CommonValidationsLibrary } from \"set-protocol-contract-utils/contracts/lib/CommonValidationsLibrary.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ISetFactory } from \"../interfaces/ISetFactory.sol\";\n\n\n/**\n * @title SetToken\n * @author Set Protocol\n *\n * Implementation of the basic Set token.\n */\ncontract SetToken is\n ERC20,\n ERC20Detailed\n{\n using SafeMath for uint256;\n\n /* ============ State Variables ============ */\n\n uint256 public naturalUnit;\n address[] public components;\n uint256[] public units;\n\n // Mapping of componentHash to isComponent\n mapping(address => bool) internal isComponent;\n\n // Address of the Factory contract that created the SetToken\n address public factory;\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for Set token\n *\n * As looping operations are expensive, checking for duplicates will be on the onus of the application developer\n *\n * @param _factory The factory used to create the Set Token\n * @param _components A list of component address which you want to include\n * @param _units A list of quantities of each component (corresponds to the Set of _components)\n * @param _naturalUnit The minimum multiple of Sets that can be issued or redeemed\n * @param _name The Set's name\n * @param _symbol The Set's symbol\n */\n constructor(\n address _factory,\n address[] memory _components,\n uint256[] memory _units,\n uint256 _naturalUnit,\n string memory _name,\n string memory _symbol\n )\n public\n ERC20Detailed(\n _name,\n _symbol,\n 18\n )\n {\n // Storing count and unit counts to local variable to save on invocation\n uint256 unitCount = _units.length;\n\n // Require naturalUnit passed is greater than 0\n require(\n _naturalUnit > 0,\n \"SetToken.constructor: Natural unit must be positive\"\n );\n\n // Confirm an empty _components array is not passed\n CommonValidationsLibrary.validateNonEmpty(_components);\n\n // Confirm there is one quantity for every token address\n CommonValidationsLibrary.validateEqualLength(_components, _units);\n\n // NOTE: It will be the onus of developers to check whether the addressExists\n // are in fact ERC20 addresses\n uint8 minDecimals = 18;\n uint8 currentDecimals;\n for (uint256 i = 0; i < unitCount; i++) {\n // Check that all units are non-zero\n uint256 currentUnits = _units[i];\n require(\n currentUnits > 0,\n \"SetToken.constructor: Units must be positive\"\n );\n\n // Check that all addresses are non-zero\n address currentComponent = _components[i];\n require(\n currentComponent != address(0),\n \"SetToken.constructor: Invalid component address\"\n );\n\n // Figure out which of the components has the minimum decimal value\n /* solium-disable-next-line security/no-low-level-calls */\n (bool success, ) = currentComponent.call(abi.encodeWithSignature(\"decimals()\"));\n if (success) {\n currentDecimals = ERC20Detailed(currentComponent).decimals();\n minDecimals = currentDecimals < minDecimals ? currentDecimals : minDecimals;\n } else {\n // If one of the components does not implement decimals, we assume the worst\n // and set minDecimals to 0\n minDecimals = 0;\n }\n\n // Check the component has not already been added\n require(\n !tokenIsComponent(currentComponent),\n \"SetToken.constructor: Duplicated component\"\n );\n\n // Add component to isComponent mapping\n isComponent[currentComponent] = true;\n\n // Add component data to components and units state variables\n components.push(currentComponent);\n units.push(currentUnits);\n }\n\n // This is the minimum natural unit possible for a Set with these components.\n require(\n _naturalUnit >= CommonMath.safePower(10, uint256(18).sub(minDecimals)),\n \"SetToken.constructor: Invalid natural unit\"\n );\n\n factory = _factory;\n naturalUnit = _naturalUnit;\n }\n\n /* ============ Public Functions ============ */\n\n /*\n * Mint set token for given address.\n * Can only be called by authorized contracts.\n *\n * @param _issuer The address of the issuing account\n * @param _quantity The number of sets to attribute to issuer\n */\n function mint(\n address _issuer,\n uint256 _quantity\n )\n external\n {\n // Check that function caller is Core\n require(\n msg.sender == ISetFactory(factory).core(),\n \"SetToken.mint: Sender must be core\"\n );\n\n _mint(_issuer, _quantity);\n }\n\n /*\n * Burn set token for given address.\n * Can only be called by authorized contracts.\n *\n * @param _from The address of the redeeming account\n * @param _quantity The number of sets to burn from redeemer\n */\n function burn(\n address _from,\n uint256 _quantity\n )\n external\n {\n // Check that function caller is Core\n require(\n msg.sender == ISetFactory(factory).core(),\n \"SetToken.burn: Sender must be core\"\n );\n\n _burn(_from, _quantity);\n }\n\n /*\n * Get addresses of all components in the Set\n *\n * @return componentAddresses Array of component tokens\n */\n function getComponents()\n external\n view\n returns (address[] memory)\n {\n return components;\n }\n\n /*\n * Get units of all tokens in Set\n *\n * @return units Array of component units\n */\n function getUnits()\n external\n view\n returns (uint256[] memory)\n {\n return units;\n }\n\n /*\n * Validates address is member of Set's components\n *\n * @param _tokenAddress Address of token being checked\n * @return bool Whether token is member of Set's components\n */\n function tokenIsComponent(\n address _tokenAddress\n )\n public\n view\n returns (bool)\n {\n return isComponent[_tokenAddress];\n }\n}\n"
},
{
"path": "contracts/core/tokens/SetTokenFactory.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { Bytes32Library } from \"set-protocol-contract-utils/contracts/lib/Bytes32Library.sol\";\n\nimport { SetToken } from \"./SetToken.sol\";\n\n\n/**\n * @title SetTokenFactory\n * @author Set Protocol\n *\n * SetTokenFactory is a smart contract used to deploy new SetToken contracts.\n * SetTokens deployed by the factory can only have their mint and burn functions\n * called by Core\n */\ncontract SetTokenFactory\n{\n using Bytes32Library for bytes32;\n\n /* ============ State Variables ============ */\n\n // Address of the Core contract\n address public core;\n\n /* ============ Constructor ============ */\n\n /**\n * Set core constructor\n *\n * @param _core The address of deployed core contract\n */\n constructor(\n address _core\n )\n public\n {\n core = _core;\n }\n\n /* ============ Public Functions ============ */\n\n /**\n * Deploys a new SetToken contract.\n * Can only be called by authorized core contracts.\n *\n * @param _components The address of component tokens\n * @param _units The units of each component token\n * @param _naturalUnit The minimum unit to be issued or redeemed\n * @param _name The bytes32 encoded name of the new Set\n * @param _symbol The bytes32 encoded symbol of the new Set\n * -- Unused callData param used to pass additional information to factories --\n * @return setToken The address of the newly created SetToken\n */\n function createSet(\n address[] calldata _components,\n uint256[] calldata _units,\n uint256 _naturalUnit,\n bytes32 _name,\n bytes32 _symbol,\n bytes calldata\n )\n external\n returns (address)\n {\n // Expecting caller to be Core\n require(\n msg.sender == core,\n \"SetTokenFactory.create: Sender must be core\"\n );\n\n // Create a new SetToken contract\n return address(\n new SetToken(\n address(this),\n _components,\n _units,\n _naturalUnit,\n _name.bytes32ToString(),\n _symbol.bytes32ToString()\n )\n );\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-libraries/FailAuctionLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { IVault } from \"../../interfaces/IVault.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\n\n\n/**\n * @title FailAuctionLibrary\n * @author Set Protocol\n *\n * Default implementation of Rebalancing Set Token endFailedAuction function\n */\nlibrary FailAuctionLibrary {\n using SafeMath for uint256;\n\n /**\n * Fail an auction that doesn't complete before reaching the pivot price. Move to Drawdown state\n * if bids have been placed. Reset to Default state if no bids placed.\n *\n * @param _startingCurrentSetAmount Amount of current set at beginning or rebalance\n * @param _calculatedUnitShares Calculated unitShares amount if rebalance were to be settled\n * @param _currentSet The Set that failed to rebalance\n * @param _coreAddress Core address\n * @param _auctionPriceParameters Struct containing auction price curve parameters\n * @param _biddingParameters Struct containing relevant data for calculating token flows\n * @param _rebalanceState State rebalancing set token is in\n * @return State of Rebalancing Set after function called\n */\n function endFailedAuction(\n uint256 _startingCurrentSetAmount,\n uint256 _calculatedUnitShares,\n address _currentSet,\n address _coreAddress,\n RebalancingLibrary.AuctionPriceParameters memory _auctionPriceParameters,\n RebalancingLibrary.BiddingParameters memory _biddingParameters,\n uint8 _rebalanceState\n )\n public\n returns (uint8)\n {\n // Token must be in Rebalance State\n require(\n _rebalanceState == uint8(RebalancingLibrary.State.Rebalance),\n \"RebalanceAuctionModule.endFailedAuction: Rebalancing Set Token must be in Rebalance State\"\n );\n\n // Calculate timestamp when pivot is reached\n uint256 revertAuctionTime = _auctionPriceParameters.auctionStartTime.add(\n _auctionPriceParameters.auctionTimeToPivot\n );\n\n // Make sure auction has gone past pivot point\n require(\n block.timestamp >= revertAuctionTime,\n \"RebalanceAuctionModule.endFailedAuction: Can only be called after auction reaches pivot\"\n );\n\n uint8 newRebalanceState;\n /**\n * If not enough sets have been bid on then allow auction to fail where no bids being registered\n * returns the rebalancing set token to pre-auction state and some bids being registered puts the\n * rebalancing set token in Drawdown mode.\n *\n * However, if enough sets have been bid on. Then allow auction to fail and enter Drawdown state if\n * and only if the calculated post-auction unitShares is equal to 0.\n */\n if (_biddingParameters.remainingCurrentSets >= _biddingParameters.minimumBid) {\n // Check if any bids have been placed\n if (_startingCurrentSetAmount == _biddingParameters.remainingCurrentSets) {\n // If bid not placed, reissue current Set\n ICore(_coreAddress).issueInVault(\n _currentSet,\n _startingCurrentSetAmount\n );\n\n // Set Rebalance Set Token state to Default\n newRebalanceState = uint8(RebalancingLibrary.State.Default);\n } else {\n // Set Rebalancing Set Token to Drawdown state\n newRebalanceState = uint8(RebalancingLibrary.State.Drawdown);\n }\n } else {\n // If settleRebalance can be called then endFailedAuction can't be unless calculatedUnitShares\n // equals 0\n require(\n _calculatedUnitShares == 0,\n \"RebalancingSetToken.endFailedAuction: Cannot be called if rebalance is viably completed\"\n );\n\n // If calculated unitShares equals 0 set to Drawdown state\n newRebalanceState = uint8(RebalancingLibrary.State.Drawdown);\n }\n\n return newRebalanceState;\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-libraries/PlaceBidLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { IAuctionPriceCurve } from \"../../lib/auction-price-libraries/IAuctionPriceCurve.sol\";\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\n\n\n/**\n * @title PlaceBidLibrary\n * @author Set Protocol\n *\n * Default implementation of Rebalancing Set Token placeBid function\n */\nlibrary PlaceBidLibrary {\n using SafeMath for uint256;\n\n /* ============ Internal Functions ============ */\n\n /*\n * Place bid during rebalance auction. Can only be called by Core.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @param _coreAddress Core address\n * @param _biddingParameters Struct containing relevant data for calculating token flows\n */\n function validatePlaceBid(\n uint256 _quantity,\n address _coreAddress,\n RebalancingLibrary.BiddingParameters memory _biddingParameters\n )\n public\n view\n {\n // Make sure sender is a module\n require(\n ICore(_coreAddress).validModules(msg.sender),\n \"RebalancingSetToken.placeBid: Sender must be approved module\"\n );\n\n // Make sure that bid amount is greater than zero\n require(\n _quantity > 0,\n \"RebalancingSetToken.placeBid: Bid must be > 0\"\n );\n\n // Make sure that bid amount is multiple of minimum bid amount\n require(\n _quantity.mod(_biddingParameters.minimumBid) == 0,\n \"RebalancingSetToken.placeBid: Must bid multiple of minimum bid\"\n );\n\n // Make sure that bid Amount is less than remainingCurrentSets\n require(\n _quantity <= _biddingParameters.remainingCurrentSets,\n \"RebalancingSetToken.placeBid: Bid exceeds remaining current sets\"\n );\n }\n\n /*\n * Get token inflows and outflows required for bid. Also the amount of Rebalancing\n * Sets that would be generated.\n *\n * @param _quantity The amount of currentSet to be rebalanced\n * @param _auctionLibrary Auction library used in rebalance\n * @param _biddingParameters Struct containing relevant data for calculating token flows\n * @param _auctionPriceParameters Struct containing auction price curve parameters\n * @param _rebalanceState State of rebalancing set token\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function getBidPrice(\n uint256 _quantity,\n address _auctionLibrary,\n RebalancingLibrary.BiddingParameters memory _biddingParameters,\n RebalancingLibrary.AuctionPriceParameters memory _auctionPriceParameters,\n uint8 _rebalanceState\n )\n public\n view\n returns (uint256[] memory, uint256[] memory)\n {\n // Confirm in Rebalance State\n require(\n _rebalanceState == uint8(RebalancingLibrary.State.Rebalance),\n \"RebalancingSetToken.getBidPrice: State must be Rebalance\"\n );\n\n // Get bid conversion price, currently static placeholder for calling auctionlibrary\n uint256 priceNumerator;\n uint256 priceDivisor;\n (priceNumerator, priceDivisor) = IAuctionPriceCurve(_auctionLibrary).getCurrentPrice(\n _auctionPriceParameters\n );\n\n // Normalized quantity amount\n uint256 unitsMultiplier = _quantity.div(_biddingParameters.minimumBid).mul(priceDivisor);\n\n // Calculate token flow arrays\n return createTokenFlowArrays(\n unitsMultiplier,\n priceNumerator,\n priceDivisor,\n _biddingParameters\n );\n }\n\n /*\n * Creates arrays of token inflows and outflows\n *\n * @param _unitsMultiplier Bid amount normalized to number of standard bid amounts\n * @param _priceNumerator The numerator of the price ratio\n * @param _priceDivisor The denominator of the price ratio\n * @param _biddingParameters Struct containing relevant data for calculating token flows\n * @return inflowUnitArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitArray Array of amount of tokens taken out of system in bid\n */\n function createTokenFlowArrays(\n uint256 _unitsMultiplier,\n uint256 _priceNumerator,\n uint256 _priceDivisor,\n RebalancingLibrary.BiddingParameters memory _biddingParameters\n )\n public\n pure\n returns (uint256[] memory, uint256[] memory)\n {\n // Declare unit arrays in memory\n uint256 combinedTokenCount = _biddingParameters.combinedTokenArray.length;\n uint256[] memory inflowUnitArray = new uint256[](combinedTokenCount);\n uint256[] memory outflowUnitArray = new uint256[](combinedTokenCount);\n\n // Cycle through each token in combinedTokenArray, calculate inflow/outflow and store\n // result in array\n for (uint256 i = 0; i < combinedTokenCount; i++) {\n (\n inflowUnitArray[i],\n outflowUnitArray[i]\n ) = calculateTokenFlows(\n _biddingParameters.combinedCurrentUnits[i],\n _biddingParameters.combinedNextSetUnits[i],\n _unitsMultiplier,\n _priceNumerator,\n _priceDivisor\n );\n }\n\n return (inflowUnitArray, outflowUnitArray);\n }\n\n /*\n * Calculates token inflow/outflow for single component in combinedTokenArray\n *\n * @param _currentUnit Amount of token i in currentSet per minimum bid amount\n * @param _nextSetUnit Amount of token i in nextSet per minimum bid amount\n * @param _unitsMultiplier Bid amount normalized to number of minimum bid amounts\n * @param _priceNumerator The numerator of the price ratio\n * @param _priceDivisor The denominator of the price ratio\n * @return inflowUnit Amount of token i transferred into the system\n * @return outflowUnit Amount of token i transferred to the bidder\n */\n function calculateTokenFlows(\n uint256 _currentUnit,\n uint256 _nextSetUnit,\n uint256 _unitsMultiplier,\n uint256 _priceNumerator,\n uint256 _priceDivisor\n )\n public\n pure\n returns (uint256, uint256)\n {\n /*\n * Below is a mathematically simplified formula for calculating token inflows and\n * outflows, the following is it's derivation:\n * token_flow = (bidQuantity/price)*(nextUnit - price*currentUnit)\n *\n * Where,\n * 1) price = (priceNumerator/priceDivisor),\n * 2) nextUnit and currentUnit are the amount of component i needed for a\n * standardAmount of sets to be rebalanced where one standardAmount =\n * max(natural unit nextSet, natural unit currentSet), and\n * 3) bidQuantity is a normalized amount in terms of the standardAmount used\n * to calculate nextUnit and currentUnit. This is represented by the unitsMultiplier\n * variable.\n *\n * Given these definitions we can derive the below formula as follows:\n * token_flow = (unitsMultiplier/(priceNumerator/priceDivisor))*\n * (nextUnit - (priceNumerator/priceDivisor)*currentUnit)\n *\n * We can then multiply this equation by (priceDivisor/priceDivisor)\n * which simplifies the above equation to:\n *\n * (unitsMultiplier/priceNumerator)* (nextUnit*priceDivisor - currentUnit*priceNumerator)\n *\n * This is the equation seen below, but since unsigned integers are used we must check to see if\n * nextUnit*priceDivisor > currentUnit*priceNumerator, otherwise those two terms must be\n * flipped in the equation.\n */\n uint256 inflowUnit;\n uint256 outflowUnit;\n\n // Use if statement to check if token inflow or outflow\n if (_nextSetUnit.mul(_priceDivisor) > _currentUnit.mul(_priceNumerator)) {\n // Calculate inflow amount\n inflowUnit = _unitsMultiplier.mul(\n _nextSetUnit.mul(_priceDivisor).sub(_currentUnit.mul(_priceNumerator))\n ).div(_priceNumerator);\n\n // Set outflow amount to 0 for component i, since tokens need to be injected in rebalance\n outflowUnit = 0;\n } else {\n // Calculate outflow amount\n outflowUnit = _unitsMultiplier.mul(\n _currentUnit.mul(_priceNumerator).sub(_nextSetUnit.mul(_priceDivisor))\n ).div(_priceNumerator);\n\n // Set inflow amount to 0 for component i, since tokens need to be returned in rebalance\n inflowUnit = 0;\n }\n\n return (inflowUnit, outflowUnit);\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-libraries/ProposeLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { IAuctionPriceCurve } from \"../../lib/auction-price-libraries/IAuctionPriceCurve.sol\";\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { IRebalancingSetFactory } from \"../../interfaces/IRebalancingSetFactory.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { IWhiteList } from \"../../interfaces/IWhiteList.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\n\n\n/**\n * @title ProposeLibrary\n * @author Set Protocol\n *\n * Default implementation of Rebalancing Set Token propose function\n */\nlibrary ProposeLibrary {\n using SafeMath for uint256;\n\n /* ============ Structs ============ */\n\n struct ProposalContext {\n address manager;\n address currentSet;\n address coreAddress;\n address componentWhitelist;\n address factoryAddress;\n uint256 lastRebalanceTimestamp;\n uint256 rebalanceInterval;\n uint8 rebalanceState;\n }\n\n /* ============ Internal Functions ============ */\n\n /**\n * Function used to validate inputs to propose function\n *\n * @param _nextSet The Set to rebalance into\n * @param _auctionLibrary The library used to calculate the Dutch Auction price\n * @param _proposalContext Rebalancing Set Token state parameters needed for proposal validation\n */\n function validateProposal(\n address _nextSet,\n address _auctionLibrary,\n ProposalContext memory _proposalContext,\n RebalancingLibrary.AuctionPriceParameters memory _auctionPriceParameters\n )\n public\n {\n ICore coreInstance = ICore(_proposalContext.coreAddress);\n IRebalancingSetFactory factoryInstance = IRebalancingSetFactory(_proposalContext.factoryAddress);\n\n // Make sure it is manager that is proposing the rebalance\n require(\n msg.sender == _proposalContext.manager,\n \"ProposeLibrary.validateProposal: Sender must be manager\"\n );\n\n // New Proposal can only be made in Default and Proposal state\n require(\n _proposalContext.rebalanceState == uint8(RebalancingLibrary.State.Default) ||\n _proposalContext.rebalanceState == uint8(RebalancingLibrary.State.Proposal),\n \"ProposeLibrary.validateProposal: State must be in Propose or Default\"\n );\n\n // Make sure enough time has passed from last rebalance to start a new proposal\n require(\n block.timestamp >= _proposalContext.lastRebalanceTimestamp.add(\n _proposalContext.rebalanceInterval\n ),\n \"ProposeLibrary.validateProposal: Rebalance interval not elapsed\"\n );\n\n // Check that new proposed Set is valid Set created by Core\n require(\n coreInstance.validSets(_nextSet),\n \"ProposeLibrary.validateProposal: Invalid or disabled proposed SetToken address\"\n );\n\n // Check proposed components on whitelist. This is to ensure managers are unable to add contract addresses\n // to a propose that prohibit the set from carrying out an auction i.e. a token that only the manager possesses\n require(\n IWhiteList(\n _proposalContext.componentWhitelist\n ).areValidAddresses(ISetToken(_nextSet).getComponents()),\n \"ProposeLibrary.validateProposal: Proposed set contains invalid component token\"\n );\n\n // Check that the auction library is a valid priceLibrary tracked by Core\n require(\n coreInstance.validPriceLibraries(_auctionLibrary),\n \"ProposeLibrary.validateProposal: Invalid or disabled PriceLibrary address\"\n );\n\n // Check that auctionTimeToPivot is greater than or equal to 6 hours\n require(\n _auctionPriceParameters.auctionTimeToPivot >= factoryInstance.minimumTimeToPivot(),\n \"ProposeLibrary.validateProposal: Time to pivot must be greater than minimum\"\n );\n\n // Check that auctionTimeToPivot is less than or equal to 3 days\n require(\n _auctionPriceParameters.auctionTimeToPivot <= factoryInstance.maximumTimeToPivot(),\n \"ProposeLibrary.validateProposal: Time to pivot must be greater than maximum\"\n );\n\n // Check that the proposed set natural unit is a multiple of current set natural unit, or vice versa.\n // Done to make sure that when calculating token units there will are no rounding errors.\n uint256 currentNaturalUnit = ISetToken(_proposalContext.currentSet).naturalUnit();\n uint256 nextSetNaturalUnit = ISetToken(_nextSet).naturalUnit();\n require(\n Math.max(currentNaturalUnit, nextSetNaturalUnit).mod(\n Math.min(currentNaturalUnit, nextSetNaturalUnit)\n ) == 0,\n \"ProposeLibrary.validateProposal: Invalid proposed Set natural unit\"\n );\n\n // Check that pivot price is compliant with library restrictions\n IAuctionPriceCurve(_auctionLibrary).validateAuctionPriceParameters(\n _auctionPriceParameters\n );\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-libraries/SettleRebalanceLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { IVault } from \"../../interfaces/IVault.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { SetTokenLibrary } from \"../../lib/SetTokenLibrary.sol\";\n\n\n/**\n * @title SettleRebalanceLibrary\n * @author Set Protocol\n *\n * Default implementation of Rebalancing Set Token settle rebalance and related functions.\n */\nlibrary SettleRebalanceLibrary {\n using SafeMath for uint256;\n /* ============ Internal Functions ============ */\n\n /**\n * Calculate the amount of nextSets to issue by using the component amounts in the\n * vault, new unitShares follow from this calculation\n *\n * @param _totalSupply Total supply of rebalancing set token\n * @param _remainingCurrentSets Amount of currentSets remaining\n * @param _minimumBid Minimum bid allowed, used to see if valid settle\n * @param _naturalUnit Natural unit of rebalancing set token\n * @param _nextSet Address of next set\n * @param _coreAddress Core address\n * @param _vaultAddress Vault address\n * @return uint256 Amount of nextSets to issue\n */\n function settleRebalance(\n uint256 _totalSupply,\n uint256 _remainingCurrentSets,\n uint256 _minimumBid,\n uint256 _naturalUnit,\n address _nextSet,\n address _coreAddress,\n address _vaultAddress,\n uint8 _rebalanceState\n )\n public\n returns (uint256)\n {\n // Must be in Rebalance state to call settlement\n require(\n _rebalanceState == uint8(RebalancingLibrary.State.Rebalance),\n \"RebalancingSetToken.settleRebalance: State must be Rebalance\"\n );\n\n // Make sure all currentSets have been rebalanced\n require(\n _remainingCurrentSets < _minimumBid,\n \"RebalancingSetToken.settleRebalance: Rebalance not completed\"\n );\n\n // Calculate next Set quantities\n uint256 issueAmount;\n uint256 nextUnitShares;\n (\n issueAmount,\n nextUnitShares\n ) = calculateNextSetIssueQuantity(\n _totalSupply,\n _naturalUnit,\n _nextSet,\n _vaultAddress\n );\n\n require(\n nextUnitShares > 0,\n \"RebalancingSetToken.settleRebalance: Failed rebalance, unitshares equals 0. Call endFailedAuction.\"\n );\n\n // Issue nextSet to RebalancingSetToken\n ICore(_coreAddress).issueInVault(\n _nextSet,\n issueAmount\n );\n\n return nextUnitShares;\n }\n\n /**\n * Calculate the amount of nextSets to issue by using the component amounts in the\n * vault, unitShares following from this calculation.\n *\n * @param _totalSupply Total supply of rebalancing set token\n * @param _naturalUnit Natural unit of rebalancing set token\n * @param _nextSet Address of next set\n * @param _vaultAddress Vault address\n * @return uint256 Amount of nextSets to issue\n * @return uint256 New unitShares for the rebalancingSetToken\n */\n function calculateNextSetIssueQuantity(\n uint256 _totalSupply,\n uint256 _naturalUnit,\n address _nextSet,\n address _vaultAddress\n )\n public\n view\n returns (uint256, uint256)\n {\n // Collect data necessary to compute issueAmounts\n SetTokenLibrary.SetDetails memory nextSetToken = SetTokenLibrary.getSetDetails(_nextSet);\n uint256 maxIssueAmount = calculateMaxIssueAmount(\n _vaultAddress,\n nextSetToken\n );\n\n // Calculate the amount of naturalUnits worth of rebalancingSetToken outstanding\n uint256 naturalUnitsOutstanding = _totalSupply.div(_naturalUnit);\n\n // Issue amount of Sets that is closest multiple of nextNaturalUnit to the maxIssueAmount\n // Since the initial division will round down to the nearest whole number when we multiply\n // by that same number we will return the closest multiple less than the maxIssueAmount\n uint256 issueAmount = maxIssueAmount.div(nextSetToken.naturalUnit).mul(nextSetToken.naturalUnit);\n\n // Divide final issueAmount by naturalUnitsOutstanding to get newUnitShares\n uint256 newUnitShares = issueAmount.div(naturalUnitsOutstanding);\n return (issueAmount, newUnitShares);\n }\n\n /**\n * Get the maximum possible issue amount of nextSet based on number of components owned by rebalancing\n * set token.\n *\n * @param _vaultAddress Vault address\n * @param _setToken nextSet details\n * @return uint256 maxIssueAmount\n */\n function calculateMaxIssueAmount(\n address _vaultAddress,\n SetTokenLibrary.SetDetails memory _setToken\n )\n public\n view\n returns (uint256)\n {\n uint256 maxIssueAmount = CommonMath.maxUInt256();\n IVault vaultInstance = IVault(_vaultAddress);\n\n for (uint256 i = 0; i < _setToken.components.length; i++) {\n // Get amount of components in vault owned by rebalancingSetToken\n uint256 componentAmount = vaultInstance.getOwnerBalance(\n _setToken.components[i],\n address(this)\n );\n\n // Calculate amount of Sets that can be issued from those components, if less than amount for other\n // components then set that as maxIssueAmount\n uint256 componentIssueAmount = componentAmount.div(_setToken.units[i]).mul(_setToken.naturalUnit);\n if (componentIssueAmount < maxIssueAmount) {\n maxIssueAmount = componentIssueAmount;\n }\n }\n\n return maxIssueAmount;\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-libraries/StartRebalanceLibrary.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\n\nimport { IAuctionPriceCurve } from \"../../lib/auction-price-libraries/IAuctionPriceCurve.sol\";\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { IVault } from \"../../interfaces/IVault.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { SetTokenLibrary } from \"../../lib/SetTokenLibrary.sol\";\n\n/**\n * @title StartRebalanceLibrary\n * @author Set Protocol\n *\n * Default implementation of Rebalancing Set Token startRebalance function\n */\n\n\nlibrary StartRebalanceLibrary {\n using SafeMath for uint256;\n using AddressArrayUtils for address[];\n\n /* ============ Internal Functions ============ */\n\n /**\n * Function used to validate time passed to start a rebalance\n *\n * @param _proposalStartTime Start time of proposal period\n * @param _proposalPeriod Required length of proposal period\n * @param _rebalanceState State rebalancing set token is in\n */\n function validateStartRebalance(\n uint256 _proposalStartTime,\n uint256 _proposalPeriod,\n uint8 _rebalanceState\n )\n external\n {\n // Must be in \"Proposal\" state before going into \"Rebalance\" state\n require(\n _rebalanceState == uint8(RebalancingLibrary.State.Proposal),\n \"RebalancingSetToken.validateStartRebalance: State must be Proposal\"\n );\n\n // Be sure the full proposal period has elapsed\n require(\n block.timestamp >= _proposalStartTime.add(_proposalPeriod),\n \"RebalancingSetToken.validateStartRebalance: Proposal period not elapsed\"\n );\n }\n\n /**\n * Function used to validate inputs to propose function and initialize biddingParameters struct\n *\n * @param _currentSet Address of current Set\n * @param _nextSet Address of next Set\n * @param _auctionLibrary Address of auction library being used in rebalance\n * @param _coreAddress Core address\n * @param _vaultAddress Vault address\n * @return Struct containing bidding parameters\n */\n function redeemCurrentSetAndGetBiddingParameters(\n address _currentSet,\n address _nextSet,\n address _auctionLibrary,\n address _coreAddress,\n address _vaultAddress\n )\n public\n returns (RebalancingLibrary.BiddingParameters memory)\n {\n // Redeem rounded quantity of current Sets and return redeemed amount of Sets\n uint256 remainingCurrentSets = redeemCurrentSet(\n _currentSet,\n _coreAddress,\n _vaultAddress\n );\n\n // Create combined array data structures and calculate minimum bid needed for auction\n RebalancingLibrary.BiddingParameters memory biddingParameters = setUpBiddingParameters(\n _currentSet,\n _nextSet,\n _auctionLibrary,\n remainingCurrentSets\n );\n\n return biddingParameters;\n }\n\n /**\n * Create struct that holds array representing all components in currentSet and nextSet.\n * Calcualate unit difference between both sets relative to the largest natural\n * unit of the two sets. Calculate minimumBid.\n *\n * @param _currentSet Address of current Set\n * @param _nextSet Address of next Set\n * @param _auctionLibrary Address of auction library being used in rebalance\n * @param _remainingCurrentSets Quantity of Current Sets redeemed\n * @return Struct containing bidding parameters\n */\n function setUpBiddingParameters(\n address _currentSet,\n address _nextSet,\n address _auctionLibrary,\n uint256 _remainingCurrentSets\n )\n public\n returns (RebalancingLibrary.BiddingParameters memory)\n {\n // Get set details for currentSet and nextSet (units, components, natural units)\n SetTokenLibrary.SetDetails memory currentSet = SetTokenLibrary.getSetDetails(_currentSet);\n SetTokenLibrary.SetDetails memory nextSet = SetTokenLibrary.getSetDetails(_nextSet);\n\n // Create combinedTokenArray\n address[] memory combinedTokenArray = currentSet.components.union(\n nextSet.components\n );\n\n // Calcualate minimumBid\n uint256 minimumBid = calculateMinimumBid(\n currentSet.naturalUnit,\n nextSet.naturalUnit,\n _auctionLibrary\n );\n\n // Require remainingCurrentSets to be greater than minimumBid otherwise no bidding would\n // be allowed\n require(\n _remainingCurrentSets >= minimumBid,\n \"RebalancingSetToken.setUpBiddingParameters: Not enough collateral to rebalance\"\n );\n\n // Create memory version of combinedNextSetUnits and combinedCurrentUnits to only make one\n // call to storage once arrays have been created\n uint256[] memory combinedCurrentUnits;\n uint256[] memory combinedNextSetUnits;\n (\n combinedCurrentUnits,\n combinedNextSetUnits\n ) = calculateCombinedUnitArrays(\n currentSet,\n nextSet,\n minimumBid,\n _auctionLibrary,\n combinedTokenArray\n );\n\n // Build Bidding Parameters struct and return\n return RebalancingLibrary.BiddingParameters({\n minimumBid: minimumBid,\n remainingCurrentSets: _remainingCurrentSets,\n combinedCurrentUnits: combinedCurrentUnits,\n combinedNextSetUnits: combinedNextSetUnits,\n combinedTokenArray: combinedTokenArray\n });\n }\n\n /**\n * Calculate the minimumBid allowed for the rebalance\n *\n * @param _currentSetNaturalUnit Natural unit of currentSet\n * @param _nextSetNaturalUnit Natural of nextSet\n * @param _auctionLibrary Address of auction library being used in rebalance\n * @return Minimum bid amount\n */\n function calculateMinimumBid(\n uint256 _currentSetNaturalUnit,\n uint256 _nextSetNaturalUnit,\n address _auctionLibrary\n )\n private\n view\n returns (uint256)\n {\n // Get priceDivisor from auctionLibrary\n uint256 priceDivisor = IAuctionPriceCurve(_auctionLibrary).priceDivisor();\n\n return Math.max(\n _currentSetNaturalUnit.mul(priceDivisor),\n _nextSetNaturalUnit.mul(priceDivisor)\n );\n }\n\n /**\n * Create arrays that represent all components in currentSet and nextSet.\n * Calcualate unit difference between both sets relative to the largest natural\n * unit of the two sets.\n *\n * @param _currentSet Information on currentSet\n * @param _nextSet Information on nextSet\n * @param _minimumBid Minimum bid amount\n * @param _auctionLibrary Address of auction library being used in rebalance\n * @param _combinedTokenArray Array of component tokens involved in rebalance\n * @return Unit inflow/outflow arrays for current and next Set\n */\n function calculateCombinedUnitArrays(\n SetTokenLibrary.SetDetails memory _currentSet,\n SetTokenLibrary.SetDetails memory _nextSet,\n uint256 _minimumBid,\n address _auctionLibrary,\n address[] memory _combinedTokenArray\n )\n public\n returns (uint256[] memory, uint256[] memory)\n {\n // Create memory version of combinedNextSetUnits and combinedCurrentUnits to only make one\n // call to storage once arrays have been created\n uint256[] memory memoryCombinedCurrentUnits = new uint256[](_combinedTokenArray.length);\n uint256[] memory memoryCombinedNextSetUnits = new uint256[](_combinedTokenArray.length);\n\n for (uint256 i = 0; i < _combinedTokenArray.length; i++) {\n memoryCombinedCurrentUnits[i] = calculateCombinedUnit(\n _currentSet,\n _minimumBid,\n _auctionLibrary,\n _combinedTokenArray[i]\n );\n\n memoryCombinedNextSetUnits[i] = calculateCombinedUnit(\n _nextSet,\n _minimumBid,\n _auctionLibrary,\n _combinedTokenArray[i]\n );\n }\n\n return (memoryCombinedCurrentUnits, memoryCombinedNextSetUnits);\n }\n\n /**\n * Calculations the unit amount of Token to include in the the combined Set units.\n *\n * @param _setToken Information on the SetToken\n * @param _minimumBid Minimum bid amount\n * @param _auctionLibrary Address of auction library being used in rebalance\n * @param _currentComponent Current component in iteration\n * @return Unit inflow/outflow\n */\n function calculateCombinedUnit(\n SetTokenLibrary.SetDetails memory _setToken,\n uint256 _minimumBid,\n address _auctionLibrary,\n address _currentComponent\n )\n private\n returns (uint256)\n {\n // Check if component in arrays and get index if it is\n uint256 indexCurrent;\n bool isComponent;\n (indexCurrent, isComponent) = _setToken.components.indexOf(_currentComponent);\n\n // Compute unit amounts of token in Set\n if (isComponent) {\n return computeTransferValue(\n _setToken.units[indexCurrent],\n _setToken.naturalUnit,\n _minimumBid,\n _auctionLibrary\n );\n }\n\n return 0;\n }\n\n /**\n * Calculates the maximum redemption quantity and redeems the Set into the vault.\n * Also updates remainingCurrentSets state variable\n *\n * @param _currentSet Address of current Set\n * @param _coreAddress Core address\n * @param _vaultAddress Vault address\n * @return Amount of currentSets remaining\n */\n function redeemCurrentSet(\n address _currentSet,\n address _coreAddress,\n address _vaultAddress\n )\n public\n returns (uint256)\n {\n // Get remainingCurrentSets and make it divisible by currentSet natural unit\n uint256 currentSetBalance = IVault(_vaultAddress).getOwnerBalance(\n _currentSet,\n address(this)\n );\n\n // Calculates the set's natural unit\n uint256 currentSetNaturalUnit = ISetToken(_currentSet).naturalUnit();\n\n // Rounds the redemption quantity to a multiple of the current Set natural unit and sets variable\n uint256 remainingCurrentSets = currentSetBalance.div(currentSetNaturalUnit).mul(currentSetNaturalUnit);\n\n ICore(_coreAddress).redeemInVault(\n _currentSet,\n remainingCurrentSets\n );\n\n return remainingCurrentSets;\n }\n\n /**\n * Function to calculate the transfer value of a component given a standardized bid amount\n * (minimumBid/priceDivisor)\n *\n * @param _unit Units of the component token\n * @param _naturalUnit Natural unit of the Set token\n * @param _minimumBid Minimum bid amount\n * @return uint256 Amount of tokens per standard bid amount (minimumBid/priceDivisor)\n */\n function computeTransferValue(\n uint256 _unit,\n uint256 _naturalUnit,\n uint256 _minimumBid,\n address _auctionLibrary\n )\n internal\n returns (uint256)\n {\n uint256 priceDivisor = IAuctionPriceCurve(_auctionLibrary).priceDivisor();\n return _minimumBid.mul(_unit).div(_naturalUnit).div(priceDivisor);\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-v2/BackwardCompatibility.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { RebalancingSetState } from \"./RebalancingSetState.sol\";\n\n\n/**\n * @title BackwardCompatibility\n * @author Set Protocol\n *\n * This module allows full backwards compatability with RebalancingSetTokenV1. It implements\n * all the same getter functions to allow upstream applications to make minimized changes\n * to support the new version.\n *\n * The following interfaces are not included:\n * - propose(address, address, uint256, uint256, uint256): Implementation would have\n *. been a revert.\n * - biddingParameters: RebalancingSetToken V1 biddingParameters reverts on call\n */\ncontract BackwardCompatibility is \n RebalancingSetState\n{\n /* ============ Empty Variables ============ */\n \n // Deprecated auctionLibrary. Returns 0x00 to prevent reverts\n address public auctionLibrary;\n\n // Deprecated proposal period. Returns 0 to prevent reverts\n uint256 public proposalPeriod;\n\n // Deprecated proposal start time. Returns 0 to prevent reverts\n uint256 public proposalStartTime;\n\n /* ============ Getters ============ */\n\n function getAuctionPriceParameters() external view returns (uint256[] memory) {\n RebalancingLibrary.AuctionPriceParameters memory params = liquidator.auctionPriceParameters(\n address(this)\n );\n\n uint256[] memory auctionPriceParams = new uint256[](4);\n auctionPriceParams[0] = params.auctionStartTime;\n auctionPriceParams[1] = params.auctionTimeToPivot;\n auctionPriceParams[2] = params.auctionStartPrice;\n auctionPriceParams[3] = params.auctionPivotPrice;\n\n return auctionPriceParams;\n }\n\n function getCombinedCurrentUnits() external view returns (uint256[] memory) {\n return liquidator.getCombinedCurrentSetUnits(address(this));\n }\n\n function getCombinedNextSetUnits() external view returns (uint256[] memory) {\n return liquidator.getCombinedNextSetUnits(address(this));\n }\n\n function getCombinedTokenArray() external view returns (address[] memory) {\n return liquidator.getCombinedTokenArray(address(this));\n }\n\n function getCombinedTokenArrayLength() external view returns (uint256) {\n return liquidator.getCombinedTokenArray(address(this)).length;\n }\n\n function startingCurrentSetAmount() external view returns (uint256) {\n return liquidator.startingCurrentSets(address(this));\n }\n\n function auctionPriceParameters() external view\n returns (RebalancingLibrary.AuctionPriceParameters memory)\n {\n return liquidator.auctionPriceParameters(address(this));\n }\n\n /*\n * Since structs with arrays cannot be retrieved, we return \n * minimumBid and remainingCurrentSets separately.\n *\n * @return biddingParams Array with minimumBid and remainingCurrentSets\n */\n function getBiddingParameters() public view returns (uint256[] memory) {\n uint256[] memory biddingParams = new uint256[](2);\n biddingParams[0] = liquidator.minimumBid(address(this));\n biddingParams[1] = liquidator.remainingCurrentSets(address(this));\n return biddingParams;\n }\n\n function biddingParameters()\n external\n view \n returns (uint256, uint256)\n {\n uint256[] memory biddingParams = getBiddingParameters();\n return (biddingParams[0], biddingParams[1]);\n }\n\n function getFailedAuctionWithdrawComponents() external view returns (address[] memory) {\n return failedRebalanceComponents;\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-v2/Issuance.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20 } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { RebalancingSetState } from \"./RebalancingSetState.sol\";\n\n\n/**\n * @title Issuance\n * @author Set Protocol\n *\n * Default implementation of Rebalancing Set Token propose function\n */\ncontract Issuance is \n ERC20,\n RebalancingSetState\n{\n using SafeMath for uint256;\n using CommonMath for uint256;\n\n /* ============ Internal Functions ============ */\n\n /*\n * Validate call to mint new Rebalancing Set Token\n *\n * - Make sure caller is Core\n * - Make sure state is not Rebalance or Drawdown\n */\n function validateMint()\n internal\n view\n {\n validateCallerIsCore();\n\n validateRebalanceStateIs(RebalancingLibrary.State.Default);\n }\n\n /*\n * Validate call to burn Rebalancing Set Token\n *\n * - Make sure state is not Rebalance or Drawdown\n * - Make sure sender is module when in drawdown, core otherwise\n */\n function validateBurn()\n internal\n view\n {\n validateRebalanceStateIsNot(RebalancingLibrary.State.Rebalance);\n\n if (rebalanceState == RebalancingLibrary.State.Drawdown) {\n // In Drawdown Sets can only be burned as part of the withdrawal process\n validateCallerIsModule();\n } else {\n // When in non-Rebalance or Drawdown state, check that function caller is Core\n // so that Sets can be redeemed\n validateCallerIsCore();\n }\n }\n /*\n * Calculates entry fees and mints the feeRecipient a portion of the issue quantity.\n *\n * @param _quantity The number of rebalancing SetTokens the issuer mints\n * @return issueQuantityNetOfFees Quantity of rebalancing SetToken to mint issuer net of fees \n */\n function handleEntryFees(\n uint256 _quantity\n )\n internal\n returns(uint256)\n {\n // The entryFee is a scaled decimal figure by 10e18. We multiply the fee by the quantity\n // Then descale by 10e18\n uint256 fee = _quantity.mul(entryFee).deScale();\n\n if (fee > 0) {\n ERC20._mint(feeRecipient, fee);\n\n emit EntryFeePaid(feeRecipient, fee);\n }\n\n // Return the issue quantity less fees\n return _quantity.sub(fee);\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-v2/RebalancingBid.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { RebalancingSetState } from \"./RebalancingSetState.sol\";\n\n\n/**\n * @title RebalancingBid\n * @author Set Protocol\n *\n * Implementation of Rebalancing Set Token V2 bidding-related functionality.\n */\ncontract RebalancingBid is\n RebalancingSetState\n{\n using SafeMath for uint256;\n\n /* ============ Internal Functions ============ */\n\n /*\n * Validates conditions to retrieve a Bid Price:\n * - State is Rebalance\n * - Quanity is greater than zero\n *\n * @param _quantity The amount of currentSet to be rebalanced\n */\n function validateGetBidPrice(\n uint256 _quantity\n )\n internal\n view\n {\n validateRebalanceStateIs(RebalancingLibrary.State.Rebalance);\n\n require(\n _quantity > 0,\n \"Bid not > 0\"\n );\n }\n\n /*\n * Validations for placeBid:\n * - Module is sender\n * - getBidPrice validations\n *\n * @param _quantity The amount of currentSet to be rebalanced\n */\n function validatePlaceBid(\n uint256 _quantity\n )\n internal\n view\n {\n validateCallerIsModule();\n\n validateGetBidPrice(_quantity);\n }\n\n /*\n * If a successful bid has been made, flip the hasBidded boolean.\n */\n function updateHasBiddedIfNecessary()\n internal\n {\n if (!hasBidded) {\n hasBidded = true;\n }\n }\n\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-v2/RebalancingFailure.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\n\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { RebalancingSetState } from \"./RebalancingSetState.sol\";\nimport { RebalancingSettlement } from \"./RebalancingSettlement.sol\";\n\n\n/**\n * @title RebalancingFailure\n * @author Set Protocol\n *\n */\ncontract RebalancingFailure is \n RebalancingSetState,\n RebalancingSettlement\n{\n using SafeMath for uint256;\n using AddressArrayUtils for address[];\n\n /* ============ Internal Functions ============ */\n\n /*\n * Validations for failRebalance:\n * - State is Rebalance\n * - Either liquidator recognizes failure OR fail period breached on RB Set\n *\n * @param _quantity The amount of currentSet to be rebalanced\n */\n function validateFailRebalance()\n internal\n view\n {\n // Token must be in Rebalance State\n validateRebalanceStateIs(RebalancingLibrary.State.Rebalance);\n\n // Failure triggers must be met\n require(\n liquidatorBreached() || failPeriodBreached(),\n \"Triggers not breached\"\n );\n }\n\n /*\n * Determine the new Rebalance State. If there has been a bid, then we put it to \n * Drawdown, where the Set is effectively killed. If no bids, we reissue the currentSet.\n */\n function getNewRebalanceState()\n internal\n view\n returns (RebalancingLibrary.State)\n {\n return hasBidded ? RebalancingLibrary.State.Drawdown : RebalancingLibrary.State.Default;\n }\n\n /*\n * Update state based on new Rebalance State.\n *\n * @param _newRebalanceState The new State to transition to\n */\n function transitionToNewState(\n RebalancingLibrary.State _newRebalanceState\n )\n internal\n {\n reissueSetIfRevertToDefault(_newRebalanceState);\n\n setWithdrawComponentsIfDrawdown(_newRebalanceState);\n\n rebalanceState = _newRebalanceState;\n rebalanceIndex = rebalanceIndex.add(1);\n lastRebalanceTimestamp = block.timestamp;\n\n nextSet = ISetToken(address(0));\n hasBidded = false;\n }\n\n /* ============ Private Functions ============ */\n\n /*\n * Returns whether the liquidator believes the rebalance has failed.\n *\n * @return If liquidator thinks rebalance failed\n */\n function liquidatorBreached()\n private\n view\n returns (bool)\n {\n return liquidator.hasRebalanceFailed(address(this));\n }\n\n /*\n * Returns whether the the fail time has elapsed, which means that a period\n * of time where the auction should have succeeded has not.\n *\n * @return If fail period has passed on Rebalancing Set Token\n */\n function failPeriodBreached()\n private\n view\n returns(bool)\n {\n uint256 rebalanceFailTime = rebalanceStartTime.add(rebalanceFailPeriod);\n\n return block.timestamp >= rebalanceFailTime;\n }\n\n /*\n * If the determination is Default State, reissue the Set.\n */\n function reissueSetIfRevertToDefault(\n RebalancingLibrary.State _newRebalanceState\n )\n private\n {\n if (_newRebalanceState == RebalancingLibrary.State.Default) {\n uint256 issueQuantity = calculateSetIssueQuantity(currentSet);\n\n // If bid not placed, reissue current Set\n core.issueInVault(\n address(currentSet),\n issueQuantity\n );\n }\n }\n\n /*\n * If the determination is Drawdown State, set the drawdown components which is the union of\n * the current and next Set components.\n */\n function setWithdrawComponentsIfDrawdown(\n RebalancingLibrary.State _newRebalanceState\n )\n private\n {\n if (_newRebalanceState == RebalancingLibrary.State.Drawdown) {\n address[] memory currentSetComponents = currentSet.getComponents();\n address[] memory nextSetComponents = nextSet.getComponents();\n\n failedRebalanceComponents = currentSetComponents.union(nextSetComponents);\n }\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-v2/RebalancingSetState.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ScaleValidations } from \"set-protocol-contract-utils/contracts/lib/ScaleValidations.sol\";\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { IFeeCalculator } from \"../../interfaces/IFeeCalculator.sol\";\nimport { ILiquidator } from \"../../interfaces/ILiquidator.sol\";\nimport { IRebalancingSetFactory } from \"../../interfaces/IRebalancingSetFactory.sol\";\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { IVault } from \"../../interfaces/IVault.sol\";\nimport { IWhiteList } from \"../../interfaces/IWhiteList.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\n\n\n/**\n * @title RebalancingSetState\n * @author Set Protocol\n *\n */\ncontract RebalancingSetState {\n\n /* ============ State Variables ============ */\n\n // ----------------------------------------------------------------------\n // System Related\n // ----------------------------------------------------------------------\n\n // Set Protocol's Core Contract\n ICore public core;\n\n // The Factory that created this Set\n IRebalancingSetFactory public factory;\n\n // Set Protocol's Vault contract\n IVault public vault;\n\n // The token whitelist that components are checked against during proposals\n IWhiteList public componentWhiteList;\n\n // WhiteList of liquidator contracts\n IWhiteList public liquidatorWhiteList;\n\n // Contract holding the state and logic required for rebalance liquidation\n // The Liquidator interacts closely with the Set during rebalances.\n ILiquidator public liquidator;\n\n // Contract responsible for calculation of rebalance fees\n IFeeCalculator public rebalanceFeeCalculator;\n\n // The account that is allowed to make proposals\n address public manager;\n\n // The account that receives any fees\n address public feeRecipient;\n\n // ----------------------------------------------------------------------\n // Configuration\n // ----------------------------------------------------------------------\n\n // Time in seconds that must elapsed from last rebalance to propose\n uint256 public rebalanceInterval;\n\n // Time in seconds after rebalanceStartTime before the Set believes the auction has failed\n uint256 public rebalanceFailPeriod;\n\n // Fee levied to feeRecipient every mint operation, paid during minting\n // Represents a decimal value scaled by 1e18 (e.g. 100% = 1e18 and 1% = 1e16)\n uint256 public entryFee;\n \n // ----------------------------------------------------------------------\n // Current State\n // ----------------------------------------------------------------------\n\n // The Set currently collateralizing the Rebalancing Set\n ISetToken public currentSet;\n\n // The number of currentSet per naturalUnit of the Rebalancing Set\n uint256 public unitShares;\n\n // The minimum issuable value of a Set\n uint256 public naturalUnit;\n\n // The current state of the Set (e.g. Default, Proposal, Rebalance, Drawdown)\n // Proposal is unused\n RebalancingLibrary.State public rebalanceState;\n\n // The number of rebalances in the Set's history; starts at index 0\n uint256 public rebalanceIndex;\n\n // The timestamp of the last completed rebalance\n uint256 public lastRebalanceTimestamp;\n\n // ----------------------------------------------------------------------\n // Live Rebalance State\n // ----------------------------------------------------------------------\n\n // The proposal's SetToken to rebalance into\n ISetToken public nextSet;\n\n // The timestamp of the last rebalance was initiated at\n uint256 public rebalanceStartTime;\n\n // Whether a successful bid has been made during the rebalance.\n // In the case that the rebalance has failed, hasBidded is used\n // to determine whether the Set should be put into Drawdown or Default state.\n bool public hasBidded;\n\n // In the event a Set is put into the Drawdown state, these components\n // that can be withdrawn by users\n address[] internal failedRebalanceComponents;\n\n /* ============ Modifier ============ */\n\n modifier onlyManager() {\n validateManager();\n _;\n }\n\n /* ============ Events ============ */\n\n event NewManagerAdded(\n address newManager,\n address oldManager\n );\n\n event NewLiquidatorAdded(\n address newLiquidator,\n address oldLiquidator\n );\n\n event NewEntryFee(\n uint256 newEntryFee,\n uint256 oldEntryFee\n );\n\n event NewFeeRecipient(\n address newFeeRecipient,\n address oldFeeRecipient\n );\n\n event EntryFeePaid(\n address indexed feeRecipient,\n uint256 feeQuantity\n );\n\n event RebalanceStarted(\n address oldSet,\n address newSet,\n uint256 rebalanceIndex,\n uint256 currentSetQuantity\n );\n\n event RebalanceSettled(\n address indexed feeRecipient,\n uint256 feeQuantity,\n uint256 feePercentage,\n uint256 rebalanceIndex,\n uint256 issueQuantity,\n uint256 unitShares\n );\n\n /* ============ Setter Functions ============ */\n\n /*\n * Set new manager address.\n */\n function setManager(\n address _newManager\n )\n external\n onlyManager\n {\n emit NewManagerAdded(_newManager, manager);\n manager = _newManager;\n }\n\n function setEntryFee(\n uint256 _newEntryFee\n )\n external\n onlyManager\n {\n ScaleValidations.validateLessThanEqualOneHundredPercent(_newEntryFee);\n\n ScaleValidations.validateMultipleOfBasisPoint(_newEntryFee);\n\n emit NewEntryFee(_newEntryFee, entryFee);\n entryFee = _newEntryFee;\n }\n\n /*\n * Set new liquidator address. Only whitelisted addresses are valid.\n */\n function setLiquidator(\n ILiquidator _newLiquidator\n )\n external\n onlyManager\n {\n require(\n rebalanceState != RebalancingLibrary.State.Rebalance,\n \"Invalid state\"\n );\n\n require(\n liquidatorWhiteList.whiteList(address(_newLiquidator)),\n \"Not whitelisted\"\n );\n\n emit NewLiquidatorAdded(address(_newLiquidator), address(liquidator));\n liquidator = _newLiquidator;\n }\n\n function setFeeRecipient(\n address _newFeeRecipient\n )\n external\n onlyManager\n {\n emit NewFeeRecipient(_newFeeRecipient, feeRecipient);\n feeRecipient = _newFeeRecipient;\n }\n\n /* ============ Getter Functions ============ */\n\n /*\n * Retrieves the current expected fee from the fee calculator\n * Value is returned as a scale decimal figure.\n */\n function rebalanceFee()\n external\n view\n returns (uint256)\n {\n return rebalanceFeeCalculator.getFee();\n }\n\n /*\n * Function for compatability with ISetToken interface. Returns currentSet.\n */\n function getComponents()\n external\n view\n returns (address[] memory)\n {\n address[] memory components = new address[](1);\n components[0] = address(currentSet);\n return components;\n }\n\n /*\n * Function for compatability with ISetToken interface. Returns unitShares.\n */\n function getUnits()\n external\n view\n returns (uint256[] memory)\n {\n uint256[] memory units = new uint256[](1);\n units[0] = unitShares;\n return units;\n }\n\n /*\n * Returns whether the address is the current set of the RebalancingSetToken.\n * Conforms to the ISetToken Interface.\n */\n function tokenIsComponent(\n address _tokenAddress\n )\n external\n view\n returns (bool)\n {\n return _tokenAddress == address(currentSet);\n }\n\n /* ============ Validations ============ */\n function validateManager() internal view {\n require(\n msg.sender == manager,\n \"Not manager\"\n );\n }\n\n function validateCallerIsCore() internal view {\n require(\n msg.sender == address(core),\n \"Not Core\"\n );\n }\n\n function validateCallerIsModule() internal view {\n require(\n core.validModules(msg.sender),\n \"Not approved module\"\n );\n }\n\n function validateRebalanceStateIs(RebalancingLibrary.State _requiredState) internal view {\n require(\n rebalanceState == _requiredState,\n \"Invalid state\"\n );\n }\n\n function validateRebalanceStateIsNot(RebalancingLibrary.State _requiredState) internal view {\n require(\n rebalanceState != _requiredState,\n \"Invalid state\"\n );\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-v2/RebalancingSettlement.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { ERC20 } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { IVault } from \"../../interfaces/IVault.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { RebalancingSetState } from \"./RebalancingSetState.sol\";\nimport { SetTokenLibrary } from \"../../lib/SetTokenLibrary.sol\";\n\n\n/**\n * @title RebalancingSettlement\n * @author Set Protocol\n *\n */\ncontract RebalancingSettlement is\n ERC20,\n RebalancingSetState\n{\n using SafeMath for uint256;\n\n uint256 public constant SCALE_FACTOR = 10 ** 18;\n\n /* ============ Internal Functions ============ */\n\n /*\n * Validates that the settle function can be called.\n */\n function validateRebalancingSettlement()\n internal\n view\n {\n validateRebalanceStateIs(RebalancingLibrary.State.Rebalance);\n }\n\n /*\n * Issue nextSet to RebalancingSetToken; The issued Set is held in the Vault\n *\n * @param _issueQuantity Quantity of next Set to issue\n */\n function issueNextSet(\n uint256 _issueQuantity\n )\n internal\n {\n core.issueInVault(\n address(nextSet),\n _issueQuantity\n );\n }\n\n /*\n * Updates state post-settlement.\n *\n * @param _nextUnitShares The new implied unit shares\n */\n function transitionToDefault(\n uint256 _newUnitShares\n )\n internal\n {\n rebalanceState = RebalancingLibrary.State.Default;\n lastRebalanceTimestamp = block.timestamp;\n currentSet = nextSet;\n unitShares = _newUnitShares;\n rebalanceIndex = rebalanceIndex.add(1);\n\n nextSet = ISetToken(address(0));\n hasBidded = false;\n }\n\n /**\n * Calculate the amount of Sets to issue by using the component amounts in the\n * vault.\n */\n function calculateSetIssueQuantity(\n ISetToken _setToken\n )\n internal\n view\n returns (uint256)\n {\n // Collect data necessary to compute issueAmounts\n SetTokenLibrary.SetDetails memory setToken = SetTokenLibrary.getSetDetails(address(_setToken));\n uint256 maxIssueAmount = calculateMaxIssueAmount(setToken);\n\n // Issue amount of Sets that is closest multiple of nextNaturalUnit to the maxIssueAmount\n uint256 issueAmount = maxIssueAmount.sub(maxIssueAmount.mod(setToken.naturalUnit));\n\n return issueAmount;\n }\n\n /**\n * Calculates the fee and mints the rebalancing SetToken quantity to the recipient.\n * The minting is done without an increase to the total collateral controlled by the\n * rebalancing SetToken. In effect, the existing holders are paying the fee via inflation.\n *\n * @return feePercentage\n * @return feeQuantity\n */\n function handleFees()\n internal\n returns (uint256, uint256)\n {\n // Represents a decimal value scaled by 1e18 (e.g. 100% = 1e18 and 1% = 1e16)\n uint256 feePercent = rebalanceFeeCalculator.getFee();\n uint256 feeQuantity = calculateRebalanceFeeInflation(feePercent);\n\n if (feeQuantity > 0) {\n ERC20._mint(feeRecipient, feeQuantity);\n }\n\n return (feePercent, feeQuantity);\n }\n\n /**\n * Returns the new rebalance fee. The calculation for the fee involves implying\n * mint quantity so that the feeRecipient owns the fee percentage of the entire\n * supply of the Set.\n *\n * The formula to solve for fee is:\n * feeQuantity / feeQuantity + totalSupply = fee / scaleFactor\n *\n * The simplified formula utilized below is:\n * feeQuantity = fee * totalSupply / (scaleFactor - fee)\n *\n * @param _rebalanceFeePercent Fee levied to feeRecipient every rebalance, paid during settlement\n * @return uint256 New RebalancingSet issue quantity\n */\n function calculateRebalanceFeeInflation(\n uint256 _rebalanceFeePercent\n )\n internal\n view\n returns(uint256)\n {\n // fee * totalSupply\n uint256 a = _rebalanceFeePercent.mul(totalSupply());\n\n // ScaleFactor (10e18) - fee\n uint256 b = SCALE_FACTOR.sub(_rebalanceFeePercent);\n\n return a.div(b);\n }\n\n /**\n * Calculates the new unitShares, defined as issueQuantity / naturalUnitsOutstanding\n *\n * @param _issueQuantity Amount of nextSets to issue\n *\n * @return uint256 New unitShares for the rebalancingSetToken\n */\n function calculateNextSetNewUnitShares(\n uint256 _issueQuantity\n )\n internal\n view\n returns (uint256)\n {\n // Calculate the amount of naturalUnits worth of rebalancingSetToken outstanding.\n uint256 naturalUnitsOutstanding = totalSupply().div(naturalUnit);\n\n // Divide final issueAmount by naturalUnitsOutstanding to get newUnitShares\n return _issueQuantity.div(naturalUnitsOutstanding);\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Get the maximum possible issue amount of nextSet based on number of components owned by rebalancing\n * set token.\n *\n * @param _setToken Struct of Set Token details\n */\n function calculateMaxIssueAmount(\n SetTokenLibrary.SetDetails memory _setToken\n )\n private\n view\n returns (uint256)\n {\n uint256 maxIssueAmount = CommonMath.maxUInt256();\n\n for (uint256 i = 0; i < _setToken.components.length; i++) {\n // Get amount of components in vault owned by rebalancingSetToken\n uint256 componentAmount = vault.getOwnerBalance(\n _setToken.components[i],\n address(this)\n );\n\n // Calculate amount of Sets that can be issued from those components, if less than amount for other\n // components then set that as maxIssueAmount. We divide before multiplying so that we don't get\n // an amount that isn't a multiple of the naturalUnit\n uint256 componentIssueAmount = componentAmount.div(_setToken.units[i]).mul(_setToken.naturalUnit);\n if (componentIssueAmount < maxIssueAmount) {\n maxIssueAmount = componentIssueAmount;\n }\n }\n\n return maxIssueAmount;\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-v2/RebalancingStart.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20 } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ISetToken } from \"../../interfaces/ISetToken.sol\";\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { RebalancingSetState } from \"./RebalancingSetState.sol\";\n\n\n/**\n * @title RebalancingStart\n * @author Set Protocol\n *\n * Implementation of Rebalancing Set Token V2 start rebalance functionality\n */\ncontract RebalancingStart is \n ERC20,\n RebalancingSetState\n{\n using SafeMath for uint256;\n\n /* ============ Internal Functions ============ */\n\n /**\n * Validate that start rebalance can be called:\n * - Current state is Default\n * - rebalanceInterval has elapsed\n * - Proposed set is valid in Core\n * - Components in set are all valid\n * - NaturalUnits are multiples of each other\n *\n * @param _nextSet The Set to rebalance into\n */\n function validateStartRebalance(\n ISetToken _nextSet\n )\n internal\n view\n {\n validateRebalanceStateIs(RebalancingLibrary.State.Default);\n\n // Enough time must have passed from last rebalance to start a new proposal\n require(\n block.timestamp >= lastRebalanceTimestamp.add(rebalanceInterval),\n \"Interval not elapsed\"\n );\n\n // Must be a positive supply of the Set\n require(\n totalSupply() > 0,\n \"Invalid supply\"\n );\n\n // New proposed Set must be a valid Set created by Core\n require(\n core.validSets(address(_nextSet)),\n \"Invalid Set\"\n );\n\n // Check proposed components on whitelist. This is to ensure managers are unable to add contract addresses\n // to a propose that prohibit the set from carrying out an auction i.e. a token that only the manager possesses\n require(\n componentWhiteList.areValidAddresses(_nextSet.getComponents()),\n \"Invalid component\"\n );\n\n // Check that the proposed set natural unit is a multiple of current set natural unit, or vice versa.\n // Done to make sure that when calculating token units there will are be rounding errors.\n require(\n naturalUnitsAreValid(currentSet, _nextSet),\n \"Invalid natural unit\"\n );\n }\n\n /**\n * Calculates the maximum quantity of the currentSet that can be redeemed. This is defined\n * by how many naturalUnits worth of the Set there are.\n *\n * @return Maximum quantity of the current Set that can be redeemed\n */\n function calculateStartingSetQuantity()\n internal\n view\n returns (uint256)\n {\n uint256 currentSetBalance = vault.getOwnerBalance(address(currentSet), address(this));\n uint256 currentSetNaturalUnit = currentSet.naturalUnit();\n\n // Rounds the redemption quantity to a multiple of the current Set natural unit\n return currentSetBalance.sub(currentSetBalance.mod(currentSetNaturalUnit));\n }\n\n /**\n * Signals to the Liquidator to initiate the rebalance.\n *\n * @param _nextSet Next set instance\n * @param _startingCurrentSetQuantity Amount of currentSets the rebalance is initiated with\n * @param _liquidatorData Bytecode formatted data with liquidator-specific arguments\n */\n function liquidatorRebalancingStart(\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n bytes memory _liquidatorData\n )\n internal\n {\n liquidator.startRebalance(\n currentSet,\n _nextSet,\n _startingCurrentSetQuantity,\n _liquidatorData \n );\n }\n\n /**\n * Updates rebalance-related state parameters.\n *\n * @param _nextSet The Set to rebalance into\n */\n function transitionToRebalance(ISetToken _nextSet) internal {\n nextSet = _nextSet;\n rebalanceState = RebalancingLibrary.State.Rebalance;\n rebalanceStartTime = block.timestamp;\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Check that the proposed set natural unit is a multiple of current set natural unit, or vice versa.\n * Done to make sure that when calculating token units there will be no rounding errors.\n *\n * @param _currentSet The current base SetToken\n * @param _nextSet The proposed SetToken\n */\n function naturalUnitsAreValid(\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n private\n view\n returns (bool)\n {\n uint256 currentNaturalUnit = _currentSet.naturalUnit();\n uint256 nextSetNaturalUnit = _nextSet.naturalUnit();\n\n return Math.max(currentNaturalUnit, nextSetNaturalUnit).mod(\n Math.min(currentNaturalUnit, nextSetNaturalUnit)\n ) == 0;\n }\n}\n"
},
{
"path": "contracts/core/tokens/rebalancing-v3/FactoryUtilsLibrary.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\nimport { ICore } from \"../../interfaces/ICore.sol\";\nimport { IWhiteList } from \"../../interfaces/IWhiteList.sol\";\nimport { LibBytes } from \"../../../external/0x/LibBytes.sol\";\nimport { SetTokenLibrary } from \"../../lib/SetTokenLibrary.sol\";\n\n\n/*\n * We segmented the FactoryUtils into it's own library to lower RebalancingSetTokenV3Factory\n * deployed bytecode size.\n */\nlibrary FactoryUtilsLibrary {\n using SafeMath for uint256;\n using LibBytes for bytes;\n\n struct InitRebalancingParameters {\n address manager;\n address liquidator;\n address feeRecipient;\n address rebalanceFeeCalculator;\n uint256 rebalanceInterval;\n uint256 rebalanceFailPeriod;\n uint256 lastRebalanceTimestamp;\n uint256 entryFee;\n bytes rebalanceFeeCalculatorData;\n }\n\n /*\n * Performs set calldata validations\n */\n function validateRebalanceSetCalldata(\n InitRebalancingParameters memory _parameters,\n address _liquidatorWhitelist,\n address _feeCalculatorWhitelist,\n uint256 _minimumRebalanceInterval,\n uint256 _minimumFailRebalancePeriod,\n uint256 _maximumFailRebalancePeriod\n )\n public\n view\n {\n require(\n _parameters.manager != address(0),\n \"Null manager\"\n );\n\n require(\n _parameters.lastRebalanceTimestamp <= block.timestamp,\n \"Bad RebalanceTimestamp\"\n );\n\n // Require liquidator address is non-zero and is whitelisted by the liquidatorWhitelist\n require(\n _parameters.liquidator != address(0) &&\n IWhiteList(_liquidatorWhitelist).whiteList(_parameters.liquidator),\n \"Bad liquidator\"\n );\n\n // Require rebalance fee calculator is whitelisted by the liquidatorWhitelist\n require(\n IWhiteList(_feeCalculatorWhitelist).whiteList(address(_parameters.rebalanceFeeCalculator)),\n \"Bad fee calculator\"\n );\n\n require(\n _parameters.rebalanceInterval >= _minimumRebalanceInterval,\n \"Bad Rebalance interval\"\n );\n\n require(\n _parameters.rebalanceFailPeriod >= _minimumFailRebalancePeriod &&\n _parameters.rebalanceFailPeriod <= _maximumFailRebalancePeriod,\n \"Bad Fail Period\"\n );\n }\n\n /**\n * Parses the calldata, which is configured as follows:\n *\n *\n * | CallData | Location |\n * |----------------------------|-------------------------------|\n * | manager | 32 |\n * | liquidator | 64 |\n * | feeRecipient | 96 |\n * | rebalanceFeeCalculator | 128 |\n * | rebalanceInterval | 160 |\n * | rebalanceFailPeriod | 192 |\n * | entryFee | 224 |\n * | rebalanceFeeCalculatorData | 256 to end |\n */\n function parseRebalanceSetCallData(\n bytes memory _callData\n )\n public\n pure\n returns (InitRebalancingParameters memory)\n {\n InitRebalancingParameters memory parameters;\n\n assembly {\n mstore(parameters, mload(add(_callData, 32))) // manager\n mstore(add(parameters, 32), mload(add(_callData, 64))) // liquidator\n mstore(add(parameters, 64), mload(add(_callData, 96))) // feeRecipient\n mstore(add(parameters, 96), mload(add(_callData, 128))) // rebalanceFeeCalculator\n mstore(add(parameters, 128), mload(add(_callData, 160))) // rebalanceInterval\n mstore(add(parameters, 160), mload(add(_callData, 192))) // rebalanceFailPeriod\n mstore(add(parameters, 192), mload(add(_callData, 224))) // lastRebalanceTimestamp\n mstore(add(parameters, 224), mload(add(_callData, 256))) // entryFee\n }\n\n // Extracts the fee calculator data from the remaining calldata\n parameters.rebalanceFeeCalculatorData = _callData.slice(256, _callData.length);\n\n return parameters;\n }\n\n function validateRebalancingSet(\n SetTokenLibrary.SetDetails memory _setDetails,\n address _core,\n address _sender,\n uint256 _minimumNaturalUnit,\n uint256 _maximumNaturalUnit\n )\n public\n view\n {\n ICore coreInstance = ICore(_core);\n\n require(\n _sender == address(coreInstance),\n \"Must be core\"\n );\n\n // Ensure component array only includes one address which will be the currentSet\n require(\n _setDetails.components.length == 1 &&\n _setDetails.units.length == 1,\n \"Components or units len != 1\"\n );\n\n require(\n _setDetails.units[0] > 0,\n \"UnitShares not > 0\"\n );\n\n // Expect Set to rebalance to be valid and enabled Set\n require(\n coreInstance.validSets(_setDetails.components[0]),\n \"Bad Set\"\n );\n\n // Natural unit must be within minimum and maximum bounds\n require(\n _setDetails.naturalUnit >= _minimumNaturalUnit &&\n _setDetails.naturalUnit <= _maximumNaturalUnit,\n \"Bad natural unit\"\n );\n }\n}\n\n"
},
{
"path": "contracts/core/tokens/rebalancing-v3/IncentiveFee.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { ERC20 } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { RebalancingLibrary } from \"../../lib/RebalancingLibrary.sol\";\nimport { RebalancingSetState } from \"../rebalancing-v2/RebalancingSetState.sol\";\n\n\n/**\n * @title IncentiveFee\n * @author Set Protocol\n */\ncontract IncentiveFee is\n ERC20,\n RebalancingSetState\n{\n using SafeMath for uint256;\n using CommonMath for uint256;\n\n /* ============ Events ============ */\n\n event IncentiveFeePaid(\n address indexed feeRecipient,\n uint256 feeQuantity,\n uint256 feePercentage,\n uint256 newUnitShares\n );\n\n /* ============ Internal Functions ============ */\n\n /**\n * Calculates the fee and mints the rebalancing SetToken quantity to the recipient.\n * The minting is done without an increase to the total collateral controlled by the\n * rebalancing SetToken. In effect, the existing holders are paying the fee via inflation.\n *\n * @return feePercentage\n * @return feeQuantity\n */\n function handleFees()\n internal\n returns (uint256, uint256)\n {\n // Represents a decimal value scaled by 1e18 (e.g. 100% = 1e18 and 1% = 1e16)\n uint256 feePercent = rebalanceFeeCalculator.updateAndGetFee();\n uint256 feeQuantity = calculateIncentiveFeeInflation(feePercent);\n\n if (feeQuantity > 0) {\n ERC20._mint(feeRecipient, feeQuantity);\n }\n\n return (feePercent, feeQuantity);\n }\n\n /**\n * Returns the new incentive fee. The calculation for the fee involves implying\n * mint quantity so that the feeRecipient owns the fee percentage of the entire\n * supply of the Set.\n *\n * The formula to solve for fee is:\n * feeQuantity / feeQuantity + totalSupply = fee / scaleFactor\n *\n * The simplified formula utilized below is:\n * feeQuantity = fee * totalSupply / (scaleFactor - fee)\n *\n * @param _feePercentage Fee levied to feeRecipient\n * @return uint256 New RebalancingSet issue quantity\n */\n function calculateIncentiveFeeInflation(\n uint256 _feePercentage\n )\n internal\n view\n returns(uint256)\n {\n // fee * totalSupply\n uint256 a = _feePercentage.mul(totalSupply());\n\n // ScaleFactor (10e18) - fee\n uint256 b = CommonMath.scaleFactor().sub(_feePercentage);\n\n return a.div(b);\n }\n\n /*\n * The Rebalancing SetToken must be in Default state.\n */\n function validateFeeActualization() internal view {\n validateRebalanceStateIs(RebalancingLibrary.State.Default);\n }\n\n /*\n * After the minting of new inflation fees, the unit shares must be updated.\n * The formula is as follows:\n * newUnitShares = currentSetAmount * rebalanceSetNaturalUnit / rebalanceSetTotalSupply\n */\n function calculateNewUnitShares() internal view returns(uint256) {\n uint256 currentSetAmount = vault.getOwnerBalance(\n address(currentSet),\n address(this)\n );\n\n return currentSetAmount.mul(naturalUnit).divCeil(totalSupply());\n }\n}\n"
},
{
"path": "contracts/external/0x/AssetProxy/interfaces/IAssetData.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\n// @dev Interface of the asset proxy's assetData.\n// The asset proxies take an ABI encoded `bytes assetData` as argument.\n// This argument is ABI encoded as one of the methods of this interface.\ninterface IAssetData {\n\n function ERC20Token(\n address tokenContract)\n external pure;\n\n function ERC721Token(\n address tokenContract,\n uint256 tokenId,\n bytes calldata receiverData)\n external pure;\n\n}\n"
},
{
"path": "contracts/external/0x/AssetProxy/interfaces/IAssetProxy.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\npragma experimental ABIEncoderV2;\n\nimport \"./IAuthorizable.sol\";\n\ncontract IAssetProxy is\n IAuthorizable\n{\n\n /// @dev Transfers assets. Either succeeds or throws.\n /// @param assetData Byte array encoded for the respective asset proxy.\n /// @param from Address to transfer asset from.\n /// @param to Address to transfer asset to.\n /// @param amount Amount of asset to transfer.\n function transferFrom(\n bytes calldata assetData,\n address from,\n address to,\n uint256 amount\n )\n external;\n\n /// @dev Gets the proxy id associated with the proxy address.\n /// @return Proxy id.\n function getProxyId()\n external\n view\n returns (bytes4);\n}\n"
},
{
"path": "contracts/external/0x/AssetProxy/interfaces/IAuthorizable.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\npragma experimental ABIEncoderV2;\n\n/*\n * Ownable\n *\n * Base contract with an owner.\n * Provides onlyOwner modifier, which prevents function from running if it is called by anyone other than the owner.\n */\n\ncontract IOwnable {\n function transferOwnership(address newOwner)\n external;\n}\n\ncontract IAuthorizable is\n IOwnable\n{\n\n /// @dev Gets all authorized addresses.\n /// @return Array of authorized addresses.\n function getAuthorizedAddresses()\n external\n view\n returns (address[] memory);\n\n /// @dev Authorizes an address.\n /// @param target Address to authorize.\n function addAuthorizedAddress(address target)\n external;\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n function removeAuthorizedAddress(address target)\n external;\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n /// @param index Index of target in authorities array.\n function removeAuthorizedAddressAtIndex(\n address target,\n uint256 index\n )\n external;\n}\n"
},
{
"path": "contracts/external/0x/AssetProxy/libs/LibAssetProxyErrors.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\n/// @dev This contract documents the revert reasons used in the AssetProxy contracts.\n/// This contract is intended to serve as a reference, but is not actually used for efficiency reasons.\ncontract LibAssetProxyErrors {\n\n /// Authorizable errors ///\n string constant SENDER_NOT_AUTHORIZED = \"SENDER_NOT_AUTHORIZED\"; // Sender not authorized to call this method.\n string constant TARGET_NOT_AUTHORIZED = \"TARGET_NOT_AUTHORIZED\"; // Target address not authorized to call this method.\n string constant TARGET_ALREADY_AUTHORIZED = \"TARGET_ALREADY_AUTHORIZED\"; // Target address must not already be authorized.\n string constant INDEX_OUT_OF_BOUNDS = \"INDEX_OUT_OF_BOUNDS\"; // Specified array index is out of bounds.\n string constant AUTHORIZED_ADDRESS_MISMATCH = \"AUTHORIZED_ADDRESS_MISMATCH\"; // Address at index does not match given target address.\n\n /// Transfer errors ///\n string constant INVALID_AMOUNT = \"INVALID_AMOUNT\"; // Transfer amount must equal 1.\n string constant TRANSFER_FAILED = \"TRANSFER_FAILED\"; // Transfer failed.\n string constant LENGTH_GREATER_THAN_131_REQUIRED = \"LENGTH_GREATER_THAN_131_REQUIRED\"; // Byte array must have a length greater than 0.\n}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/IAssetProxyDispatcher.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\ncontract IAssetProxyDispatcher {\n\n /// @dev Registers an asset proxy to an asset proxy id.\n /// An id can only be assigned to a single proxy at a given time.\n /// @param assetProxyId Id to register`newAssetProxy` under.\n /// @param newAssetProxy Address of new asset proxy to register, or 0x0 to unset assetProxyId.\n /// @param oldAssetProxy Existing asset proxy to overwrite, or 0x0 if assetProxyId is currently unused.\n function registerAssetProxy(\n bytes4 assetProxyId,\n address newAssetProxy,\n address oldAssetProxy\n )\n external;\n\n /// @dev Gets an asset proxy.\n /// @param assetProxyId Id of the asset proxy.\n /// @return The asset proxy registered to assetProxyId. Returns 0x0 if no proxy is registered.\n function getAssetProxy(bytes4 assetProxyId)\n external\n view\n returns (address);\n}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/IExchange.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\npragma experimental ABIEncoderV2;\n\nimport \"./IExchangeCore.sol\";\nimport \"./IMatchOrders.sol\";\nimport \"./ISignatureValidator.sol\";\nimport \"./ITransactions.sol\";\nimport \"./IAssetProxyDispatcher.sol\";\nimport \"./IWrapperFunctions.sol\";\n\ncontract IExchange is\n IExchangeCore,\n IMatchOrders,\n ISignatureValidator,\n ITransactions,\n IAssetProxyDispatcher,\n IWrapperFunctions\n{}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/IExchangeCore.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\npragma experimental ABIEncoderV2;\n\nimport \"../libs/LibOrder.sol\";\nimport \"../libs/LibFillResults.sol\";\n\ncontract IExchangeCore {\n\n /// @dev Cancels all orders created by makerAddress with a salt less than or equal to the targetOrderEpoch\n /// and senderAddress equal to msg.sender (or null address if msg.sender == makerAddress).\n /// @param targetOrderEpoch Orders created with a salt less or equal to this value will be cancelled.\n function cancelOrdersUpTo(uint256 targetOrderEpoch)\n external;\n\n /// @dev Fills the input order.\n /// @param order Order struct containing order specifications.\n /// @param takerAssetFillAmount Desired amount of takerAsset to sell.\n /// @param signature Proof that order has been created by maker.\n /// @return Amounts filled and fees paid by maker and taker.\n function fillOrder(\n LibOrder.Order memory order,\n uint256 takerAssetFillAmount,\n bytes memory signature\n )\n public\n returns (LibFillResults.FillResults memory fillResults);\n\n /// @dev After calling, the order can not be filled anymore.\n /// @param order Order struct containing order specifications.\n function cancelOrder(LibOrder.Order memory order)\n public;\n\n /// @dev Gets information about an order: status, hash, and amount filled.\n /// @param order Order to gather information on.\n /// @return OrderInfo Information about the order and its state.\n /// See LibOrder.OrderInfo for a complete description.\n function getOrderInfo(LibOrder.Order memory order)\n public\n view\n returns (LibOrder.OrderInfo memory orderInfo);\n}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/IMatchOrders.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\npragma solidity 0.5.7;\npragma experimental ABIEncoderV2;\n\nimport \"../libs/LibOrder.sol\";\nimport \"../libs/LibFillResults.sol\";\n\ncontract IMatchOrders {\n\n /// @dev Match two complementary orders that have a profitable spread.\n /// Each order is filled at their respective price point. However, the calculations are\n /// carried out as though the orders are both being filled at the right order's price point.\n /// The profit made by the left order goes to the taker (who matched the two orders).\n /// @param leftOrder First order to match.\n /// @param rightOrder Second order to match.\n /// @param leftSignature Proof that order was created by the left maker.\n /// @param rightSignature Proof that order was created by the right maker.\n /// @return matchedFillResults Amounts filled and fees paid by maker and taker of matched orders.\n /// TODO: Make this function external once supported by Solidity (See Solidity Issues #3199, #1603)\n function matchOrders(\n LibOrder.Order memory leftOrder,\n LibOrder.Order memory rightOrder,\n bytes memory leftSignature,\n bytes memory rightSignature\n )\n public\n returns (LibFillResults.MatchedFillResults memory matchedFillResults);\n}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/ISignatureValidator.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\ncontract ISignatureValidator {\n\n /// @dev Approves a hash on-chain using any valid signature type.\n /// After presigning a hash, the preSign signature type will become valid for that hash and signer.\n /// @param signerAddress Address that should have signed the given hash.\n /// @param signature Proof that the hash has been signed by signer.\n function preSign(\n bytes32 hash,\n address signerAddress,\n bytes calldata signature\n )\n external;\n\n /// @dev Approves/unnapproves a Validator contract to verify signatures on signer's behalf.\n /// @param validatorAddress Address of Validator contract.\n /// @param approval Approval or disapproval of Validator contract.\n function setSignatureValidatorApproval(\n address validatorAddress,\n bool approval\n )\n external;\n\n /// @dev Verifies that a signature is valid.\n /// @param hash Message hash that is signed.\n /// @param signerAddress Address of signer.\n /// @param signature Proof of signing.\n /// @return Validity of order signature.\n function isValidSignature(\n bytes32 hash,\n address signerAddress,\n bytes memory signature\n )\n public\n view\n returns (bool isValid);\n}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/ITransactions.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\npragma solidity 0.5.7;\n\ncontract ITransactions {\n\n /// @dev Executes an exchange method call in the context of signer.\n /// @param salt Arbitrary number to ensure uniqueness of transaction hash.\n /// @param signerAddress Address of transaction signer.\n /// @param data AbiV2 encoded calldata.\n /// @param signature Proof of signer transaction by signer.\n function executeTransaction(\n uint256 salt,\n address signerAddress,\n bytes calldata data,\n bytes calldata signature\n )\n external;\n}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/IValidator.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\ncontract IValidator {\n\n /// @dev Verifies that a signature is valid.\n /// @param hash Message hash that is signed.\n /// @param signerAddress Address that should have signed the given hash.\n /// @param signature Proof of signing.\n /// @return Validity of order signature.\n function isValidSignature(\n bytes32 hash,\n address signerAddress,\n bytes calldata signature\n )\n external\n view\n returns (bool isValid);\n}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/IWallet.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\ncontract IWallet {\n\n /// @dev Verifies that a signature is valid.\n /// @param hash Message hash that is signed.\n /// @param signature Proof of signing.\n /// @return Validity of order signature.\n function isValidSignature(\n bytes32 hash,\n bytes calldata signature\n )\n external\n view\n returns (bool isValid);\n}\n"
},
{
"path": "contracts/external/0x/Exchange/interfaces/IWrapperFunctions.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\npragma experimental ABIEncoderV2;\n\nimport \"../libs/LibOrder.sol\";\nimport \"../libs/LibFillResults.sol\";\n\ncontract IWrapperFunctions {\n /// @dev Fills the input order. Reverts if exact takerAssetFillAmount not filled.\n /// @param order LibOrder.Order struct containing order specifications.\n /// @param takerAssetFillAmount Desired amount of takerAsset to sell.\n /// @param signature Proof that order has been created by maker.\n function fillOrKillOrder(\n LibOrder.Order memory order,\n uint256 takerAssetFillAmount,\n bytes memory signature\n )\n public\n returns (LibFillResults.FillResults memory fillResults);\n\n /// @dev Fills an order with specified parameters and ECDSA signature.\n /// Returns false if the transaction would otherwise revert.\n /// @param order LibOrder.Order struct containing order specifications.\n /// @param takerAssetFillAmount Desired amount of takerAsset to sell.\n /// @param signature Proof that order has been created by maker.\n /// @return Amounts filled and fees paid by maker and taker.\n function fillOrderNoThrow(\n LibOrder.Order memory order,\n uint256 takerAssetFillAmount,\n bytes memory signature\n )\n public\n returns (LibFillResults.FillResults memory fillResults);\n\n /// @dev Synchronously executes multiple calls of fillOrder.\n /// @param orders Array of order specifications.\n /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders.\n /// @param signatures Proofs that orders have been created by makers.\n /// @return Amounts filled and fees paid by makers and taker.\n function batchFillOrders(\n LibOrder.Order[] memory orders,\n uint256[] memory takerAssetFillAmounts,\n bytes[] memory signatures\n )\n public\n returns (LibFillResults.FillResults memory totalFillResults);\n\n /// @dev Synchronously executes multiple calls of fillOrKill.\n /// @param orders Array of order specifications.\n /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders.\n /// @param signatures Proofs that orders have been created by makers.\n /// @return Amounts filled and fees paid by makers and taker.\n function batchFillOrKillOrders(\n LibOrder.Order[] memory orders,\n uint256[] memory takerAssetFillAmounts,\n bytes[] memory signatures\n )\n public\n returns (LibFillResults.FillResults memory totalFillResults);\n\n /// @dev Fills an order with specified parameters and ECDSA signature.\n /// Returns false if the transaction would otherwise revert.\n /// @param orders Array of order specifications.\n /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders.\n /// @param signatures Proofs that orders have been created by makers.\n /// @return Amounts filled and fees paid by makers and taker.\n function batchFillOrdersNoThrow(\n LibOrder.Order[] memory orders,\n uint256[] memory takerAssetFillAmounts,\n bytes[] memory signatures\n )\n public\n returns (LibFillResults.FillResults memory totalFillResults);\n\n /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerAsset is sold by taker.\n /// @param orders Array of order specifications.\n /// @param takerAssetFillAmount Desired amount of takerAsset to sell.\n /// @param signatures Proofs that orders have been created by makers.\n /// @return Amounts filled and fees paid by makers and taker.\n function marketSellOrders(\n LibOrder.Order[] memory orders,\n uint256 takerAssetFillAmount,\n bytes[] memory signatures\n )\n public\n returns (LibFillResults.FillResults memory totalFillResults);\n\n /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerAsset is sold by taker.\n /// Returns false if the transaction would otherwise revert.\n /// @param orders Array of order specifications.\n /// @param takerAssetFillAmount Desired amount of takerAsset to sell.\n /// @param signatures Proofs that orders have been signed by makers.\n /// @return Amounts filled and fees paid by makers and taker.\n function marketSellOrdersNoThrow(\n LibOrder.Order[] memory orders,\n uint256 takerAssetFillAmount,\n bytes[] memory signatures\n )\n public\n returns (LibFillResults.FillResults memory totalFillResults);\n\n /// @dev Synchronously executes multiple calls of fillOrder until total amount of makerAsset is bought by taker.\n /// @param orders Array of order specifications.\n /// @param makerAssetFillAmount Desired amount of makerAsset to buy.\n /// @param signatures Proofs that orders have been signed by makers.\n /// @return Amounts filled and fees paid by makers and taker.\n function marketBuyOrders(\n LibOrder.Order[] memory orders,\n uint256 makerAssetFillAmount,\n bytes[] memory signatures\n )\n public\n returns (LibFillResults.FillResults memory totalFillResults);\n\n /// @dev Synchronously executes multiple fill orders in a single transaction until total amount is bought by taker.\n /// Returns false if the transaction would otherwise revert.\n /// @param orders Array of order specifications.\n /// @param makerAssetFillAmount Desired amount of makerAsset to buy.\n /// @param signatures Proofs that orders have been signed by makers.\n /// @return Amounts filled and fees paid by makers and taker.\n function marketBuyOrdersNoThrow(\n LibOrder.Order[] memory orders,\n uint256 makerAssetFillAmount,\n bytes[] memory signatures\n )\n public\n returns (LibFillResults.FillResults memory totalFillResults);\n\n /// @dev Synchronously cancels multiple orders in a single transaction.\n /// @param orders Array of order specifications.\n function batchCancelOrders(LibOrder.Order[] memory orders)\n public;\n}\n"
},
{
"path": "contracts/external/0x/Exchange/libs/LibConstants.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\ncontract LibConstants {\n\n // Asset data for ZRX token. Used for fee transfers.\n // @TODO: Hardcode constant when we deploy. Currently\n // not constant to make testing easier.\n bytes public ZRX_ASSET_DATA;\n}\n"
},
{
"path": "contracts/external/0x/Exchange/libs/LibEIP712.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\ncontract LibEIP712 {\n // EIP191 header for EIP712 prefix\n string constant EIP191_HEADER = \"\\x19\\x01\";\n\n // EIP712 Domain Name value\n string constant EIP712_DOMAIN_NAME = \"0x Protocol\";\n\n // EIP712 Domain Version value\n string constant EIP712_DOMAIN_VERSION = \"2\";\n\n // Hash of the EIP712 Domain Separator Schema\n bytes32 public constant EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256(abi.encodePacked(\n \"EIP712Domain(\",\n \"string name,\",\n \"string version,\",\n \"address verifyingContract\",\n \")\"\n ));\n\n // Hash of the EIP712 Domain Separator data\n bytes32 public EIP712_DOMAIN_HASH;\n}\n"
},
{
"path": "contracts/external/0x/Exchange/libs/LibExchangeErrors.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\n/// @dev This contract documents the revert reasons used in the Exchange contract.\n/// This contract is intended to serve as a reference, but is not actually used for efficiency reasons.\ncontract LibExchangeErrors {\n\n /// Order validation errors ///\n string constant ORDER_UNFILLABLE = \"ORDER_UNFILLABLE\"; // Order cannot be filled.\n string constant INVALID_MAKER = \"INVALID_MAKER\"; // Invalid makerAddress.\n string constant INVALID_TAKER = \"INVALID_TAKER\"; // Invalid takerAddress.\n string constant INVALID_SENDER = \"INVALID_SENDER\"; // Invalid `msg.sender`.\n string constant INVALID_ORDER_SIGNATURE = \"INVALID_ORDER_SIGNATURE\"; // Signature validation failed.\n\n /// fillOrder validation errors ///\n string constant INVALID_TAKER_AMOUNT = \"INVALID_TAKER_AMOUNT\"; // takerAssetFillAmount cannot equal 0.\n string constant ROUNDING_ERROR = \"ROUNDING_ERROR\"; // Rounding error greater than 0.1% of takerAssetFillAmount.\n\n /// Signature validation errors ///\n string constant INVALID_SIGNATURE = \"INVALID_SIGNATURE\"; // Signature validation failed.\n string constant SIGNATURE_ILLEGAL = \"SIGNATURE_ILLEGAL\"; // Signature type is illegal.\n string constant SIGNATURE_UNSUPPORTED = \"SIGNATURE_UNSUPPORTED\"; // Signature type unsupported.\n\n /// cancelOrdersUptTo errors ///\n string constant INVALID_NEW_ORDER_EPOCH = \"INVALID_NEW_ORDER_EPOCH\"; // Specified salt must be greater than or equal to existing orderEpoch.\n\n /// fillOrKillOrder errors ///\n string constant COMPLETE_FILL_FAILED = \"COMPLETE_FILL_FAILED\"; // Desired takerAssetFillAmount could not be completely filled.\n\n /// matchOrders errors ///\n string constant NEGATIVE_SPREAD_REQUIRED = \"NEGATIVE_SPREAD_REQUIRED\"; // Matched orders must have a negative spread.\n\n /// Transaction errors ///\n string constant REENTRANCY_ILLEGAL = \"REENTRANCY_ILLEGAL\"; // Recursive reentrancy is not allowed.\n string constant INVALID_TX_HASH = \"INVALID_TX_HASH\"; // Transaction has already been executed.\n string constant INVALID_TX_SIGNATURE = \"INVALID_TX_SIGNATURE\"; // Signature validation failed.\n string constant FAILED_EXECUTION = \"FAILED_EXECUTION\"; // Transaction execution failed.\n\n /// registerAssetProxy errors ///\n string constant ASSET_PROXY_MISMATCH = \"ASSET_PROXY_MISMATCH\"; // oldAssetProxy proxy does not match currentAssetProxy.\n string constant ASSET_PROXY_ID_MISMATCH = \"ASSET_PROXY_ID_MISMATCH\"; // newAssetProxyId does not match given assetProxyId.\n\n /// dispatchTransferFrom errors ///\n string constant ASSET_PROXY_DOES_NOT_EXIST = \"ASSET_PROXY_DOES_NOT_EXIST\"; // No assetProxy registered at given id.\n string constant TRANSFER_FAILED = \"TRANSFER_FAILED\"; // Asset transfer unsuccesful.\n\n /// Length validation errors ///\n string constant LENGTH_GREATER_THAN_0_REQUIRED = \"LENGTH_GREATER_THAN_0_REQUIRED\"; // Byte array must have a length greater than 0.\n string constant LENGTH_GREATER_THAN_3_REQUIRED = \"LENGTH_GREATER_THAN_3_REQUIRED\"; // Byte array must have a length greater than 3.\n string constant LENGTH_0_REQUIRED = \"LENGTH_0_REQUIRED\"; // Byte array must have a length of 0.\n string constant LENGTH_65_REQUIRED = \"LENGTH_65_REQUIRED\"; // Byte array must have a length of 65.\n}\n"
},
{
"path": "contracts/external/0x/Exchange/libs/LibFillResults.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\ncontract LibFillResults\n{\n struct FillResults {\n uint256 makerAssetFilledAmount; // Total amount of makerAsset(s) filled.\n uint256 takerAssetFilledAmount; // Total amount of takerAsset(s) filled.\n uint256 makerFeePaid; // Total amount of ZRX paid by maker(s) to feeRecipient(s).\n uint256 takerFeePaid; // Total amount of ZRX paid by taker to feeRecipients(s).\n }\n\n struct MatchedFillResults {\n FillResults left; // Amounts filled and fees paid of left order.\n FillResults right; // Amounts filled and fees paid of right order.\n uint256 leftMakerAssetSpreadAmount; // Spread between price of left and right order, denominated in the left order's makerAsset, paid to taker.\n }\n}\n"
},
{
"path": "contracts/external/0x/Exchange/libs/LibOrder.sol",
"content": "/*\n\n Copyright 2018 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity 0.5.7;\n\nimport \"./LibEIP712.sol\";\n\ncontract LibOrder is\n LibEIP712\n{\n\n // Hash for the EIP712 Order Schema\n bytes32 constant EIP712_ORDER_SCHEMA_HASH = keccak256(abi.encodePacked(\n \"Order(\",\n \"address makerAddress,\",\n \"address takerAddress,\",\n \"address feeRecipientAddress,\",\n \"address senderAddress,\",\n \"uint256 makerAssetAmount,\",\n \"uint256 takerAssetAmount,\",\n \"uint256 makerFee,\",\n \"uint256 takerFee,\",\n \"uint256 expirationTimeSeconds,\",\n \"uint256 salt,\",\n \"bytes makerAssetData,\",\n \"bytes takerAssetData\",\n \")\"\n ));\n\n // A valid order remains fillable until it is expired, fully filled, or cancelled.\n // An order's state is unaffected by external factors, like account balances.\n enum OrderStatus {\n INVALID, // Default value\n INVALID_MAKER_ASSET_AMOUNT, // Order does not have a valid maker asset amount\n INVALID_TAKER_ASSET_AMOUNT, // Order does not have a valid taker asset amount\n FILLABLE, // Order is fillable\n EXPIRED, // Order has already expired\n FULLY_FILLED, // Order is fully filled\n CANCELLED // Order has been cancelled\n }\n\n struct Order {\n address makerAddress; // Address that created the order.\n address takerAddress; // Address that is allowed to fill the order. If set to 0, any address is allowed to fill the order.\n address feeRecipientAddress; // Address that will recieve fees when order is filled.\n address senderAddress; // Address that is allowed to call Exchange contract methods that affect this order. If set to 0, any address is allowed to call these methods.\n uint256 makerAssetAmount; // Amount of makerAsset being offered by maker. Must be greater than 0.\n uint256 takerAssetAmount; // Amount of takerAsset being bid on by maker. Must be greater than 0.\n uint256 makerFee; // Amount of ZRX paid to feeRecipient by maker when order is filled. If set to 0, no transfer of ZRX from maker to feeRecipient will be attempted.\n uint256 takerFee; // Amount of ZRX paid to feeRecipient by taker when order is filled. If set to 0, no transfer of ZRX from taker to feeRecipient will be attempted.\n uint256 expirationTimeSeconds; // Timestamp in seconds at which order expires.\n uint256 salt; // Arbitrary number to facilitate uniqueness of the order's hash.\n bytes makerAssetData; // Encoded data that can be decoded by a specified proxy contract when transferring makerAsset. The last byte references the id of this proxy.\n bytes takerAssetData; // Encoded data that can be decoded by a specified proxy contract when transferring takerAsset. The last byte references the id of this proxy.\n }\n\n struct OrderInfo {\n uint8 orderStatus; // Status that describes order's validity and fillability.\n bytes32 orderHash; // EIP712 hash of the order (see LibOrder.getOrderHash).\n uint256 orderTakerAssetFilledAmount; // Amount of order that has already been filled.\n }\n}\n"
},
{
"path": "contracts/external/0x/LibBytes.sol",
"content": "/*\n Copyright 2018 ZeroEx Intl.\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n http://www.apache.org/licenses/LICENSE-2.0\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nlibrary LibBytes {\n\n using LibBytes for bytes;\n\n /// @dev Gets the memory address for the contents of a byte array.\n /// @param input Byte array to lookup.\n /// @return memoryAddress Memory address of the contents of the byte array.\n function contentAddress(bytes memory input)\n internal\n pure\n returns (uint256 memoryAddress)\n {\n assembly {\n memoryAddress := add(input, 32)\n }\n return memoryAddress;\n }\n\n /// @dev Reads an unpadded bytes4 value from a position in a byte array.\n /// @param b Byte array containing a bytes4 value.\n /// @param index Index in byte array of bytes4 value.\n /// @return bytes4 value from byte array.\n function readBytes4(\n bytes memory b,\n uint256 index)\n internal\n pure\n returns (bytes4 result)\n {\n require(\n b.length >= index + 4,\n \"GREATER_OR_EQUAL_TO_4_LENGTH_REQUIRED\"\n );\n assembly {\n result := mload(add(b, 32))\n // Solidity does not require us to clean the trailing bytes.\n // We do it anyway\n result := and(result, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)\n }\n return result;\n }\n\n\n /// @dev Reads a bytes32 value from a position in a byte array.\n /// @param b Byte array containing a bytes32 value.\n /// @param index Index in byte array of bytes32 value.\n /// @return bytes32 value from byte array.\n function readBytes32(\n bytes memory b,\n uint256 index\n )\n internal\n pure\n returns (bytes32 result)\n {\n require(\n b.length >= index + 32,\n \"GREATER_OR_EQUAL_TO_32_LENGTH_REQUIRED\"\n );\n\n // Arrays are prefixed by a 256 bit length parameter\n index += 32;\n\n // Read the bytes32 from array memory\n assembly {\n result := mload(add(b, index))\n }\n return result;\n }\n\n /// @dev Copies `length` bytes from memory location `source` to `dest`.\n /// @param dest memory address to copy bytes to.\n /// @param source memory address to copy bytes from.\n /// @param length number of bytes to copy.\n function memCopy(\n uint256 dest,\n uint256 source,\n uint256 length\n )\n internal\n pure\n {\n if (length < 32) {\n // Handle a partial word by reading destination and masking\n // off the bits we are interested in.\n // This correctly handles overlap, zero lengths and source == dest\n assembly {\n let mask := sub(exp(256, sub(32, length)), 1)\n let s := and(mload(source), not(mask))\n let d := and(mload(dest), mask)\n mstore(dest, or(s, d))\n }\n } else {\n // Skip the O(length) loop when source == dest.\n if (source == dest) {\n return;\n }\n\n // For large copies we copy whole words at a time. The final\n // word is aligned to the end of the range (instead of after the\n // previous) to handle partial words. So a copy will look like this:\n //\n // ####\n // ####\n // ####\n // ####\n //\n // We handle overlap in the source and destination range by\n // changing the copying direction. This prevents us from\n // overwriting parts of source that we still need to copy.\n //\n // This correctly handles source == dest\n //\n if (source > dest) {\n assembly {\n // We subtract 32 from `sEnd` and `dEnd` because it\n // is easier to compare with in the loop, and these\n // are also the addresses we need for copying the\n // last bytes.\n length := sub(length, 32)\n let sEnd := add(source, length)\n let dEnd := add(dest, length)\n\n // Remember the last 32 bytes of source\n // This needs to be done here and not after the loop\n // because we may have overwritten the last bytes in\n // source already due to overlap.\n let last := mload(sEnd)\n\n // Copy whole words front to back\n // Note: the first check is always true,\n // this could have been a do-while loop.\n for {} lt(source, sEnd) {} {\n mstore(dest, mload(source))\n source := add(source, 32)\n dest := add(dest, 32)\n }\n\n // Write the last 32 bytes\n mstore(dEnd, last)\n }\n } else {\n assembly {\n // We subtract 32 from `sEnd` and `dEnd` because those\n // are the starting points when copying a word at the end.\n length := sub(length, 32)\n let sEnd := add(source, length)\n let dEnd := add(dest, length)\n\n // Remember the first 32 bytes of source\n // This needs to be done here and not after the loop\n // because we may have overwritten the first bytes in\n // source already due to overlap.\n let first := mload(source)\n\n // Copy whole words back to front\n // We use a signed comparisson here to allow dEnd to become\n // negative (happens when source and dest < 32). Valid\n // addresses in local memory will never be larger than\n // 2**255, so they can be safely re-interpreted as signed.\n // Note: the first check is always true,\n // this could have been a do-while loop.\n for {} slt(dest, dEnd) {} {\n mstore(dEnd, mload(sEnd))\n sEnd := sub(sEnd, 32)\n dEnd := sub(dEnd, 32)\n }\n\n // Write the first 32 bytes\n mstore(dest, first)\n }\n }\n }\n }\n\n /// @dev Returns a slices from a byte array.\n /// @param b The byte array to take a slice from.\n /// @param from The starting index for the slice (inclusive).\n /// @param to The final index for the slice (exclusive).\n /// @return result The slice containing bytes at indices [from, to)\n function slice(bytes memory b, uint256 from, uint256 to)\n internal\n pure\n returns (bytes memory result)\n {\n require(\n from <= to,\n \"FROM_LESS_THAN_TO_REQUIRED\"\n );\n require(\n // NOTE: Set Protocol changed from `to < b.length` so that the last byte can be sliced off\n to <= b.length,\n \"TO_LESS_THAN_LENGTH_REQUIRED\"\n );\n\n // Create a new bytes structure and copy contents\n result = new bytes(to - from);\n memCopy(\n result.contentAddress(),\n b.contentAddress() + from,\n result.length);\n return result;\n }\n}\n"
},
{
"path": "contracts/external/KyberNetwork/KyberNetworkProxyInterface.sol",
"content": "pragma solidity 0.5.7;\n\n\n/// @title Kyber Network interface\ninterface KyberNetworkProxyInterface {\n function getExpectedRate(\n address src,\n address dest,\n uint256 srcQty\n )\n external\n view\n returns (uint256 expectedRate, uint256 slippageRate);\n\n function trade(\n address src,\n uint srcAmount,\n address dest,\n address destAddress,\n uint maxDestAmount,\n uint minConversionRate,\n address walletId\n )\n external\n payable\n returns (uint);\n}\n"
},
{
"path": "contracts/helper/RebalancingSetCTokenBidder.sol",
"content": " /*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\nimport { CompoundUtils } from \"set-protocol-contract-utils/contracts/lib/CompoundUtils.sol\";\n\nimport { ERC20Wrapper } from \"../lib/ERC20Wrapper.sol\";\nimport { ICToken } from \"../core/interfaces/ICToken.sol\";\nimport { IRebalanceAuctionModule } from \"../core/interfaces/IRebalanceAuctionModule.sol\";\nimport { IRebalancingSetToken } from \"../core/interfaces/IRebalancingSetToken.sol\";\nimport { IRebalancingSetTokenV3 } from \"../core/interfaces/IRebalancingSetTokenV3.sol\";\nimport { ITransferProxy } from \"../core/interfaces/ITransferProxy.sol\";\nimport { ITWAPAuctionGetters } from \"../core/interfaces/ITWAPAuctionGetters.sol\";\nimport { Rebalance } from \"../core/lib/Rebalance.sol\";\n\n\n/**\n * @title RebalancingSetCTokenBidder\n * @author Set Protocol\n *\n * A helper contract that mints a cToken from its underlying or redeems a cToken into \n * its underlying used for bidding in the RebalanceAuctionModule.\n * \n * CHANGELOG 6/8/2020:\n * - Remove reentrant modifier on bidAndWithdraw. This modifier is already used in RebalanceAuctionModule\n * - Add bidAndWithdrawTWAP function to check that bids can only succeed for the current auction chunk\n */\ncontract RebalancingSetCTokenBidder is\n ReentrancyGuard\n{\n using SafeMath for uint256;\n \n // Address and instance of RebalanceAuctionModule contract\n IRebalanceAuctionModule public rebalanceAuctionModule;\n\n // Address and instance of TransferProxy contract\n ITransferProxy public transferProxy;\n\n // Mapping of cToken address to underlying address\n mapping (address => address) public cTokenToUnderlying;\n\n string public dataDescription;\n\n /* ============ Events ============ */\n\n event BidPlacedCToken(\n address indexed rebalancingSetToken,\n address indexed bidder,\n uint256 quantity\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for RebalancingSetCTokenBidder\n *\n * @param _rebalanceAuctionModule The address of RebalanceAuctionModule\n * @param _transferProxy The address of TransferProxy\n * @param _cTokenArray The address array of the target cToken\n * @param _underlyingArray The address array of the target cToken's underlying\n * @param _dataDescription Description of contract for Etherscan / other applications\n */\n constructor(\n IRebalanceAuctionModule _rebalanceAuctionModule,\n ITransferProxy _transferProxy,\n address[] memory _cTokenArray,\n address[] memory _underlyingArray,\n string memory _dataDescription\n )\n public\n {\n rebalanceAuctionModule = _rebalanceAuctionModule;\n\n transferProxy = _transferProxy;\n\n dataDescription = _dataDescription;\n\n require(\n _cTokenArray.length == _underlyingArray.length,\n \"RebalancingSetCTokenBidder.constructor: cToken array and underlying array must be same length\"\n );\n\n for (uint256 i = 0; i < _cTokenArray.length; i++) {\n address cTokenAddress = _cTokenArray[i];\n address underlyingAddress = _underlyingArray[i];\n\n // Initialize mapping of cToken to underlying\n cTokenToUnderlying[cTokenAddress] = underlyingAddress;\n\n // Add approvals of the underlying token to the cToken contract\n ERC20Wrapper.approve(\n underlyingAddress,\n cTokenAddress,\n CommonMath.maxUInt256()\n );\n\n // Add approvals of the cToken to the transferProxy contract\n ERC20Wrapper.approve(\n cTokenAddress,\n address(_transferProxy),\n CommonMath.maxUInt256()\n );\n }\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Bid on rebalancing a given quantity of sets held by a rebalancing token wrapping or unwrapping\n * a target cToken involved. The tokens are returned to the user.\n *\n * @param _rebalancingSetToken Instance of the rebalancing token being bid on\n * @param _quantity Number of currentSets to rebalance\n * @param _allowPartialFill Set to true if want to partially fill bid when quantity\n is greater than currentRemainingSets\n */\n\n function bidAndWithdraw(\n IRebalancingSetToken _rebalancingSetToken,\n uint256 _quantity,\n bool _allowPartialFill\n )\n public\n {\n // Get token flow arrays for the given bid quantity\n (\n address[] memory combinedTokenArray,\n uint256[] memory inflowUnitsArray,\n uint256[] memory outflowUnitsArray\n ) = Rebalance.getTokenFlows(_rebalancingSetToken, _quantity);\n\n // Ensure allowances and transfer auction tokens or underlying from user\n depositComponents(\n combinedTokenArray,\n inflowUnitsArray\n );\n\n // Bid in auction\n rebalanceAuctionModule.bidAndWithdraw(\n address(_rebalancingSetToken),\n _quantity,\n _allowPartialFill\n );\n\n // Withdraw auction tokens or underlying to user\n withdrawComponentsToSender(\n combinedTokenArray\n );\n\n // Log bid placed with Eth event\n emit BidPlacedCToken(\n address(_rebalancingSetToken),\n msg.sender,\n _quantity\n );\n }\n\n /**\n * Bid on rebalancing a given quantity of sets held by a rebalancing token wrapping or unwrapping\n * a target cToken involved. The tokens are returned to the user. This function is only compatible with\n * Rebalancing Set Tokens that use TWAP liquidators\n *\n * During a TWAP chunk auction, there is an adverse scenario where a bidder submits a chunk auction bid\n * with a low gas price and iterateChunkAuction is called before that transaction is mined. When the bidder’s\n * transaction gets mined, it may execute at an unintended price. To combat this, he BidAndWithdrawTWAP\n * function checks that a new chunk auction has not been initiated from the point of bidding. \n * The intended use case is that the bidder would retrieve the Rebalancing SetToken’s lastChunkAuctionEnd\n * variable off-chain and submit it as part of the bid.\n *\n * @param _rebalancingSetToken Instance of the rebalancing token being bid on\n * @param _quantity Number of currentSets to rebalance\n * @param _lastChunkTimestamp Timestamp of end of previous chunk auction used to identify which\n chunk the bidder wants to bid on\n * @param _allowPartialFill Set to true if want to partially fill bid when quantity\n is greater than currentRemainingSets\n */\n\n function bidAndWithdrawTWAP(\n IRebalancingSetTokenV3 _rebalancingSetToken,\n uint256 _quantity,\n uint256 _lastChunkTimestamp,\n bool _allowPartialFill\n )\n external\n {\n address liquidatorAddress = address(_rebalancingSetToken.liquidator());\n address rebalancingSetTokenAddress = address(_rebalancingSetToken);\n\n uint256 lastChunkAuctionEnd = ITWAPAuctionGetters(liquidatorAddress).getLastChunkAuctionEnd(rebalancingSetTokenAddress);\n\n require(\n lastChunkAuctionEnd == _lastChunkTimestamp,\n \"RebalancingSetCTokenBidder.bidAndWithdrawTWAP: Bid must be for intended chunk\"\n );\n\n bidAndWithdraw(\n IRebalancingSetToken(rebalancingSetTokenAddress),\n _quantity,\n _allowPartialFill\n );\n }\n\n /*\n * Get token inflows and outflows and combined token array denominated in underlying required\n * for bid for a given rebalancing Set token.\n *\n * @param _rebalancingSetToken The rebalancing Set Token instance\n * @param _quantity The amount of currentSet to be rebalanced\n * @return combinedTokenArray Array of token addresses\n * @return inflowUnitsArray Array of amount of tokens inserted into system in bid\n * @return outflowUnitsArray Array of amount of tokens returned from system in bid\n */\n function getAddressAndBidPriceArray(\n IRebalancingSetToken _rebalancingSetToken,\n uint256 _quantity\n )\n external\n view\n returns (address[] memory, uint256[] memory, uint256[] memory)\n {\n // Get token flow arrays for the given bid quantity\n (\n address[] memory combinedTokenArray,\n uint256[] memory inflowUnitsArray,\n uint256[] memory outflowUnitsArray\n ) = Rebalance.getTokenFlows(_rebalancingSetToken, _quantity);\n\n // Loop through the combined token addresses array and replace with underlying address\n for (uint256 i = 0; i < combinedTokenArray.length; i++) {\n address currentComponentAddress = combinedTokenArray[i];\n\n // Check if current component address is a cToken\n address underlyingAddress = cTokenToUnderlying[currentComponentAddress];\n if (underlyingAddress != address(0)) {\n combinedTokenArray[i] = underlyingAddress;\n\n // Replace inflow and outflow with required amount of underlying. \n // Calculated as cToken quantity * exchangeRate / 10 ** 18.\n uint256 exchangeRate = ICToken(currentComponentAddress).exchangeRateStored();\n uint256 currentInflowQuantity = inflowUnitsArray[i];\n uint256 currentOutflowQuantity = outflowUnitsArray[i];\n\n inflowUnitsArray[i] = CompoundUtils.convertCTokenToUnderlying(currentInflowQuantity, exchangeRate);\n outflowUnitsArray[i] = CompoundUtils.convertCTokenToUnderlying(currentOutflowQuantity, exchangeRate);\n }\n }\n\n return (combinedTokenArray, inflowUnitsArray, outflowUnitsArray);\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Before bidding, calculate the required amount of inflow tokens and deposit token components\n * into this helper contract.\n *\n * @param _combinedTokenArray Array of token addresses\n * @param _inflowUnitsArray Array of inflow token units\n */\n function depositComponents(\n address[] memory _combinedTokenArray,\n uint256[] memory _inflowUnitsArray\n )\n private\n {\n // Loop through the combined token addresses array and deposit inflow amounts\n for (uint256 i = 0; i < _combinedTokenArray.length; i++) {\n address currentComponentAddress = _combinedTokenArray[i];\n uint256 currentComponentQuantity = _inflowUnitsArray[i];\n\n // Check component inflow is greater than 0\n if (currentComponentQuantity > 0) {\n // Ensure allowance for components to transferProxy\n ERC20Wrapper.ensureAllowance(\n currentComponentAddress,\n address(this),\n address(transferProxy),\n currentComponentQuantity\n );\n\n // If cToken, calculate required underlying tokens, transfer to contract, \n // ensure underlying allowance to cToken and then mint cTokens\n address underlyingAddress = cTokenToUnderlying[currentComponentAddress];\n if (underlyingAddress != address(0)) {\n ICToken cTokenInstance = ICToken(currentComponentAddress);\n\n // Calculate required amount of underlying. Calculated as cToken quantity * exchangeRate / 10 ** 18.\n uint256 exchangeRate = cTokenInstance.exchangeRateCurrent();\n uint256 underlyingQuantity = CompoundUtils.convertCTokenToUnderlying(currentComponentQuantity, exchangeRate);\n\n // Transfer underlying tokens to contract\n ERC20Wrapper.transferFrom(\n underlyingAddress,\n msg.sender,\n address(this),\n underlyingQuantity\n );\n\n // Ensure allowance for underlying token to cToken contract\n ERC20Wrapper.ensureAllowance(\n underlyingAddress,\n address(this),\n address(cTokenInstance),\n underlyingQuantity\n );\n\n // Mint cToken using underlying\n uint256 mintResponse = cTokenInstance.mint(underlyingQuantity);\n require(\n mintResponse == 0,\n \"RebalancingSetCTokenBidder.bidAndWithdraw: Error minting cToken\"\n );\n } else {\n // Transfer non-cTokens to contract\n ERC20Wrapper.transferFrom(\n currentComponentAddress,\n msg.sender,\n address(this),\n currentComponentQuantity\n );\n }\n }\n }\n }\n\n /**\n * After bidding, loop through token address array and redeem any cTokens \n * and transfer token components to user\n *\n * @param _combinedTokenArray Array of token addresses\n */\n function withdrawComponentsToSender(\n address[] memory _combinedTokenArray\n )\n private\n {\n // Loop through the combined token addresses array and withdraw leftover amounts\n for (uint256 i = 0; i < _combinedTokenArray.length; i++) {\n address currentComponentAddress = _combinedTokenArray[i];\n \n // Get balance of tokens in contract\n uint256 currentComponentBalance = ERC20Wrapper.balanceOf(\n currentComponentAddress,\n address(this)\n );\n\n // Check component balance is greater than 0\n if (currentComponentBalance > 0) {\n // Check if cToken\n address underlyingAddress = cTokenToUnderlying[currentComponentAddress];\n if (underlyingAddress != address(0)) {\n // Redeem cToken into underlying\n uint256 mintResponse = ICToken(currentComponentAddress).redeem(currentComponentBalance);\n require(\n mintResponse == 0,\n \"RebalancingSetCTokenBidder.bidAndWithdraw: Erroring redeeming cToken\"\n );\n\n // Get balance of underlying in contract\n uint256 underlyingComponentBalance = ERC20Wrapper.balanceOf(\n underlyingAddress,\n address(this)\n );\n\n // Withdraw underlying from the contract and send to the user\n ERC20Wrapper.transfer(\n underlyingAddress,\n msg.sender,\n underlyingComponentBalance\n );\n } else {\n // Withdraw non cTokens from the contract and send to the user\n ERC20Wrapper.transfer(\n currentComponentAddress,\n msg.sender,\n currentComponentBalance\n );\n }\n }\n }\n }\n}"
},
{
"path": "contracts/helper/RebalancingSetEthBidder.sol",
"content": " /*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ReentrancyGuard } from \"openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { IRebalanceAuctionModule } from \"../core/interfaces/IRebalanceAuctionModule.sol\";\nimport { IRebalancingSetToken } from \"../core/interfaces/IRebalancingSetToken.sol\";\nimport { ITransferProxy } from \"../core/interfaces/ITransferProxy.sol\";\nimport { IWETH } from \"../lib/IWETH.sol\";\n\nimport { ERC20Wrapper } from \"../lib/ERC20Wrapper.sol\";\n\n\n/**\n * @title RebalancingSetEthBidder\n * @author Set Protocol\n *\n * A helper contract that wraps your ETH into WETH for bidding in the RebalanceAuctionModule.\n */\ncontract RebalancingSetEthBidder is\n ReentrancyGuard\n{\n using SafeMath for uint256;\n \n // Address and instance of RebalanceAuctionModule contract\n IRebalanceAuctionModule public rebalanceAuctionModule;\n\n // Address and instance of TransferProxy contract\n ITransferProxy public transferProxy;\n\n // Address and instance of Wrapped Ether contract\n IWETH public weth;\n\n /* ============ Events ============ */\n\n event BidPlacedWithEth(\n address indexed rebalancingSetToken,\n address indexed bidder,\n uint256 quantity\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for RebalancingSetEthBidder\n *\n * @param _rebalanceAuctionModule The address of RebalanceAuctionModule\n * @param _transferProxy The address of TransferProxy\n * @param _weth The address of Wrapped Ether\n */\n constructor(\n IRebalanceAuctionModule _rebalanceAuctionModule,\n ITransferProxy _transferProxy,\n IWETH _weth\n )\n public\n {\n // Commit the RebalanceAuctionModule instance\n rebalanceAuctionModule = _rebalanceAuctionModule;\n\n // Commit the TransferProxy instance\n transferProxy = _transferProxy;\n\n // Commit the WETH instance\n weth = _weth;\n\n // Add approvals of Wrapped Ether to the Transfer Proxy\n ERC20Wrapper.approve(\n address(_weth),\n address(_transferProxy),\n CommonMath.maxUInt256()\n );\n }\n\n /**\n * Fallback function. Disallows ether to be sent to this contract without data except when\n * unwrapping WETH.\n */\n function ()\n external\n payable\n {\n require(\n msg.sender == address(weth),\n \"RebalancingSetEthBidder.fallback: Cannot receive ETH directly unless unwrapping WETH\"\n );\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Bid on rebalancing a given quantity of sets held by a rebalancing token wrapping or unwrapping\n * any ETH involved. The tokens are returned to the user.\n *\n * @param _rebalancingSetToken Instance of the rebalancing token being bid on\n * @param _quantity Number of currentSets to rebalance\n * @param _allowPartialFill Set to true if want to partially fill bid when quantity\n is greater than currentRemainingSets\n */\n\n function bidAndWithdrawWithEther(\n IRebalancingSetToken _rebalancingSetToken,\n uint256 _quantity,\n bool _allowPartialFill\n )\n external\n payable\n nonReentrant\n {\n // Wrap all Ether sent to the contract\n weth.deposit.value(msg.value)();\n\n // Get token addresses\n address[] memory combinedTokenArray = _rebalancingSetToken.getCombinedTokenArray();\n\n // Get inflow and outflow arrays for the given bid quantity\n uint256[] memory inflowArray;\n uint256[] memory outflowArray;\n (\n inflowArray,\n outflowArray\n ) = _rebalancingSetToken.getBidPrice(_quantity);\n\n // Ensure allowances and transfer non-weth tokens from user\n depositNonWethComponents(\n combinedTokenArray,\n inflowArray\n );\n\n // Bid in auction\n rebalanceAuctionModule.bidAndWithdraw(\n address(_rebalancingSetToken),\n _quantity,\n _allowPartialFill\n );\n\n // Withdraw non-weth tokens to user\n withdrawNonWethComponentsToSender(\n combinedTokenArray\n );\n\n // Unwrap all remaining Ether and transfer to user\n uint256 wethBalance = ERC20Wrapper.balanceOf(address(weth), address(this));\n if (wethBalance > 0) {\n weth.withdraw(wethBalance);\n msg.sender.transfer(wethBalance); \n }\n\n // Log bid placed with Eth event\n emit BidPlacedWithEth(\n address(_rebalancingSetToken),\n msg.sender,\n _quantity\n );\n }\n\n /* ============ Private Functions ============ */\n\n /**\n * Before bidding, calculate the required amount of inflow tokens and deposit token components\n * into this helper contract.\n *\n * @param _combinedTokenArray Array of token addresses\n * @param _inflowArray Array of inflow token units\n */\n function depositNonWethComponents(\n address[] memory _combinedTokenArray,\n uint256[] memory _inflowArray\n )\n private\n {\n // Loop through the combined token addresses array and deposit inflow amounts\n for (uint256 i = 0; i < _combinedTokenArray.length; i++) {\n address currentComponent = _combinedTokenArray[i];\n uint256 currentComponentQuantity = _inflowArray[i];\n\n // Check component inflow is greater than 0\n if (currentComponentQuantity > 0) {\n // Ensure allowance for components to transferProxy\n ERC20Wrapper.ensureAllowance(\n address(currentComponent),\n address(this),\n address(transferProxy),\n currentComponentQuantity\n );\n\n // If not WETH, transfer tokens from user to contract\n if (currentComponent != address(weth)) {\n // Transfer tokens to contract\n ERC20Wrapper.transferFrom(\n address(currentComponent),\n msg.sender,\n address(this),\n currentComponentQuantity\n );\n }\n }\n }\n }\n\n /**\n * After bidding, loop through token address array and transfer\n * token components except wrapped ether to the sender\n *\n * @param _combinedTokenArray Array of token addresses\n */\n function withdrawNonWethComponentsToSender(\n address[] memory _combinedTokenArray\n )\n private\n {\n // Loop through the combined token addresses array and withdraw leftover amounts\n for (uint256 i = 0; i < _combinedTokenArray.length; i++) {\n address currentComponent = _combinedTokenArray[i];\n \n // Get balance of tokens in contract\n uint256 currentComponentBalance = ERC20Wrapper.balanceOf(\n currentComponent,\n address(this)\n );\n\n // Check component balance is greater than 0\n if (currentComponentBalance > 0 && currentComponent != address(weth)) {\n // Withdraw tokens from the contract and send to the user\n ERC20Wrapper.transfer(\n address(currentComponent),\n msg.sender,\n currentComponentBalance\n );\n }\n }\n }\n}"
},
{
"path": "contracts/lib/AddressToAddressWhiteList.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\nimport { TimeLockUpgradeV2 } from \"set-protocol-contract-utils/contracts/lib/TimeLockUpgradeV2.sol\";\n\n\n/**\n * @title AddressToAddressWhiteList\n * @author Set Protocol\n *\n * WhiteList that matches addresses to other addresses\n */\ncontract AddressToAddressWhiteList is\n TimeLockUpgradeV2\n{\n using AddressArrayUtils for address[];\n\n /* ============ State Variables ============ */\n\n address[] public keys;\n mapping(address => address) public whitelist;\n\n /* ============ Events ============ */\n\n event PairAdded(\n address indexed key,\n address value\n );\n\n event PairRemoved(\n address indexed key,\n address value\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for AddressToAddressWhiteList\n *\n * Allow initial addresses to be passed in so a separate transaction is not required for each.\n * Each key type address passed is matched with a corresponding value type token address at the same index.\n * The _initialKeys and _initialValues arrays must be equal length.\n *\n * @param _initialKeys Starting set of key type addresses to whitelist\n * @param _initialValues Starting set of value type addresses to whitelist\n */\n constructor(\n address[] memory _initialKeys,\n address[] memory _initialValues\n )\n public\n {\n require(\n _initialKeys.length == _initialValues.length,\n \"AddressToAddressWhiteList.constructor: Address array lengths must match.\"\n );\n\n // Add each of initial addresses to state\n for (uint256 i = 0; i < _initialKeys.length; i++) {\n address keyTypeAddressToAdd = _initialKeys[i];\n\n // Require keys are unique\n require(\n whitelist[keyTypeAddressToAdd] == address(0),\n \"AddressToAddressWhiteList.constructor: Key must be unique.\"\n );\n\n // Require values are non zero addresses\n require(\n _initialValues[i] != address(0),\n \"AddressToAddressWhiteList.constructor: Value must be non zero.\"\n );\n\n keys.push(keyTypeAddressToAdd);\n whitelist[keyTypeAddressToAdd] = _initialValues[i];\n }\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Add an address to the whitelist\n *\n * @param _key Key type address to add to the whitelist\n * @param _value Value type address to add to the whitelist under _key\n */\n function addPair(\n address _key,\n address _value\n )\n external\n timeLockUpgrade\n {\n require(\n whitelist[_key] == address(0),\n \"AddressToAddressWhiteList.addPair: Address pair already exists.\"\n );\n\n require(\n _value != address(0),\n \"AddressToAddressWhiteList.addPair: Value must be non zero.\"\n );\n\n keys.push(_key);\n whitelist[_key] = _value;\n\n emit PairAdded(_key, _value);\n }\n\n /**\n * Remove a address to address pair from the whitelist\n *\n * @param _key Key type address to remove to the whitelist\n */\n function removePair(\n address _key\n )\n external\n timeLockUpgrade\n {\n address valueToRemove = whitelist[_key];\n\n require(\n valueToRemove != address(0),\n \"AddressToAddressWhiteList.removePair: key type address is not current whitelisted.\"\n );\n\n keys = keys.remove(_key);\n whitelist[_key] = address(0);\n\n emit PairRemoved(_key, valueToRemove);\n }\n\n /**\n * Edit value type address associated with a key\n *\n * @param _key Key type address to add to the whitelist\n * @param _value Value type address to add to the whitelist under _key\n */\n function editPair(\n address _key,\n address _value\n )\n external\n timeLockUpgrade\n {\n require(\n whitelist[_key] != address(0),\n \"AddressToAddressWhiteList.editPair: Address pair must exist.\"\n );\n\n require(\n _value != address(0),\n \"AddressToAddressWhiteList.editPair: New value must be non zero.\"\n );\n\n emit PairRemoved(\n _key,\n whitelist[_key]\n );\n\n // Set new value type address for passed key type address\n whitelist[_key] = _value;\n\n emit PairAdded(\n _key,\n _value\n );\n }\n\n /**\n * Return array of all whitelisted addresses\n *\n * @return address[] Array of key type addresses\n */\n function validAddresses()\n external\n view\n returns (address[] memory)\n {\n return keys;\n }\n\n /**\n * Return array of value type addresses based on passed in key type addresses \n *\n * @param _key Array of key type addresses to get value type addresses for\n * @return address[] Array of value type addresses\n */\n function getValues(\n address[] calldata _key\n )\n external\n view\n returns (address[] memory)\n {\n // Get length of passed array\n uint256 arrayLength = _key.length;\n\n // Instantiate value type addresses array\n address[] memory values = new address[](arrayLength);\n\n for (uint256 i = 0; i < arrayLength; i++) {\n // Get value type address for key type address at index i\n values[i] = getValue(\n _key[i]\n );\n }\n\n return values; \n }\n\n /**\n * Return value type address associated with a passed key type address \n *\n * @param _key Address of key type\n * @return address Address associated with _key \n */\n function getValue(\n address _key\n )\n public\n view\n returns (address)\n {\n // Require key to have matching value type address\n require(\n whitelist[_key] != address(0),\n \"AddressToAddressWhiteList.getValue: No value for that address.\"\n );\n\n // Return address associated with key\n return whitelist[_key]; \n }\n\n /**\n * Verifies an array of addresses against the whitelist\n *\n * @param _keys Array of key type addresses to check if value exists\n * @return bool Whether all addresses in the list are whitelisted\n */\n function areValidAddresses(\n address[] calldata _keys\n )\n external\n view\n returns (bool)\n {\n // Get length of passed array\n uint256 arrayLength = _keys.length;\n\n for (uint256 i = 0; i < arrayLength; i++) {\n // Return false if key type address doesn't have matching value type address\n if (whitelist[_keys[i]] == address(0)) {\n return false;\n }\n }\n\n return true;\n }\n}"
},
{
"path": "contracts/lib/ERC20Wrapper.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { IERC20 } from \"./IERC20.sol\";\n\n\n/**\n * @title ERC20Wrapper\n * @author Set Protocol\n *\n * This library contains functions for interacting wtih ERC20 tokens, even those not fully compliant.\n * For all functions we will only accept tokens that return a null or true value, any other values will\n * cause the operation to revert.\n */\nlibrary ERC20Wrapper {\n\n // ============ Internal Functions ============\n\n /**\n * Check balance owner's balance of ERC20 token\n *\n * @param _token The address of the ERC20 token\n * @param _owner The owner who's balance is being checked\n * @return uint256 The _owner's amount of tokens\n */\n function balanceOf(\n address _token,\n address _owner\n )\n external\n view\n returns (uint256)\n {\n return IERC20(_token).balanceOf(_owner);\n }\n\n /**\n * Checks spender's allowance to use token's on owner's behalf.\n *\n * @param _token The address of the ERC20 token\n * @param _owner The token owner address\n * @param _spender The address the allowance is being checked on\n * @return uint256 The spender's allowance on behalf of owner\n */\n function allowance(\n address _token,\n address _owner,\n address _spender\n )\n internal\n view\n returns (uint256)\n {\n return IERC20(_token).allowance(_owner, _spender);\n }\n\n /**\n * Transfers tokens from an address. Handle's tokens that return true or null.\n * If other value returned, reverts.\n *\n * @param _token The address of the ERC20 token\n * @param _to The address to transfer to\n * @param _quantity The amount of tokens to transfer\n */\n function transfer(\n address _token,\n address _to,\n uint256 _quantity\n )\n external\n {\n IERC20(_token).transfer(_to, _quantity);\n\n // Check that transfer returns true or null\n require(\n checkSuccess(),\n \"ERC20Wrapper.transfer: Bad return value\"\n );\n }\n\n /**\n * Transfers tokens from an address (that has set allowance on the proxy).\n * Handle's tokens that return true or null. If other value returned, reverts.\n *\n * @param _token The address of the ERC20 token\n * @param _from The address to transfer from\n * @param _to The address to transfer to\n * @param _quantity The number of tokens to transfer\n */\n function transferFrom(\n address _token,\n address _from,\n address _to,\n uint256 _quantity\n )\n external\n {\n IERC20(_token).transferFrom(_from, _to, _quantity);\n\n // Check that transferFrom returns true or null\n require(\n checkSuccess(),\n \"ERC20Wrapper.transferFrom: Bad return value\"\n );\n }\n\n /**\n * Grants spender ability to spend on owner's behalf.\n * Handle's tokens that return true or null. If other value returned, reverts.\n *\n * @param _token The address of the ERC20 token\n * @param _spender The address to approve for transfer\n * @param _quantity The amount of tokens to approve spender for\n */\n function approve(\n address _token,\n address _spender,\n uint256 _quantity\n )\n internal\n {\n IERC20(_token).approve(_spender, _quantity);\n\n // Check that approve returns true or null\n require(\n checkSuccess(),\n \"ERC20Wrapper.approve: Bad return value\"\n );\n }\n\n /**\n * Ensure's the owner has granted enough allowance for system to\n * transfer tokens.\n *\n * @param _token The address of the ERC20 token\n * @param _owner The address of the token owner\n * @param _spender The address to grant/check allowance for\n * @param _quantity The amount to see if allowed for\n */\n function ensureAllowance(\n address _token,\n address _owner,\n address _spender,\n uint256 _quantity\n )\n internal\n {\n uint256 currentAllowance = allowance(_token, _owner, _spender);\n if (currentAllowance < _quantity) {\n approve(\n _token,\n _spender,\n CommonMath.maxUInt256()\n );\n }\n }\n\n // ============ Private Functions ============\n\n /**\n * Checks the return value of the previous function up to 32 bytes. Returns true if the previous\n * function returned 0 bytes or 1.\n */\n function checkSuccess(\n )\n private\n pure\n returns (bool)\n {\n // default to failure\n uint256 returnValue = 0;\n\n assembly {\n // check number of bytes returned from last function call\n switch returndatasize\n\n // no bytes returned: assume success\n case 0x0 {\n returnValue := 1\n }\n\n // 32 bytes returned\n case 0x20 {\n // copy 32 bytes into scratch space\n returndatacopy(0x0, 0x0, 0x20)\n\n // load those bytes into returnValue\n returnValue := mload(0x0)\n }\n\n // not sure what was returned: dont mark as success\n default { }\n }\n\n // check if returned value is one or nothing\n return returnValue == 1;\n }\n}\n"
},
{
"path": "contracts/lib/IERC20.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title IERC20\n * @author Set Protocol\n *\n * Interface for using ERC20 Tokens. This interface is needed to interact with tokens that are not\n * fully ERC20 compliant and return something other than true on successful transfers.\n */\ninterface IERC20 {\n function balanceOf(\n address _owner\n )\n external\n view\n returns (uint256);\n\n function allowance(\n address _owner,\n address _spender\n )\n external\n view\n returns (uint256);\n\n function transfer(\n address _to,\n uint256 _quantity\n )\n external;\n\n function transferFrom(\n address _from,\n address _to,\n uint256 _quantity\n )\n external;\n\n function approve(\n address _spender,\n uint256 _quantity\n )\n external\n returns (bool);\n\n function totalSupply()\n external\n returns (uint256);\n}\n"
},
{
"path": "contracts/lib/IWETH.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\n/**\n * @title IWETH\n * @author Set Protocol\n *\n * Interface for Wrapped Ether. This interface allows for interaction for wrapped ether's deposit and withdrawal\n * functionality.\n */\ninterface IWETH {\n function deposit()\n external\n payable;\n\n function withdraw(\n uint256 wad\n )\n external;\n}\n"
},
{
"path": "contracts/lib/OracleWhiteList.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\nimport { Ownable } from \"openzeppelin-solidity/contracts/ownership/Ownable.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\nimport { TimeLockUpgradeV2 } from \"set-protocol-contract-utils/contracts/lib/TimeLockUpgradeV2.sol\";\n\n\n/**\n * @title OracleWhiteList\n * @author Set Protocol\n *\n * WhiteList that matches whitelisted tokens to their on chain price oracle\n */\ncontract OracleWhiteList is\n Ownable,\n TimeLockUpgradeV2\n{\n using AddressArrayUtils for address[];\n\n /* ============ State Variables ============ */\n\n address[] public addresses;\n mapping(address => address) public oracleWhiteList;\n\n /* ============ Events ============ */\n\n event TokenOraclePairAdded(\n address _tokenAddress,\n address _oracleAddress\n );\n\n event TokenOraclePairRemoved(\n address _tokenAddress,\n address _oracleAddress\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for OracleWhiteList\n *\n * Allow initial addresses to be passed in so a separate transaction is not required for each.\n * Each token address passed is matched with a corresponding oracle address at the same index.\n * The _initialTokenAddresses and _initialOracleAddresses arrays must be equal length.\n *\n * @param _initialTokenAddresses Starting set of toke addresses to whitelist\n * @param _initialOracleAddresses Starting set of oracle addresses to whitelist\n */\n constructor(\n address[] memory _initialTokenAddresses,\n address[] memory _initialOracleAddresses\n )\n public\n {\n require(\n _initialTokenAddresses.length == _initialOracleAddresses.length,\n \"OracleWhiteList.constructor: Token and Oracle array lengths must match.\"\n );\n\n // Add each of initial addresses to state\n for (uint256 i = 0; i < _initialTokenAddresses.length; i++) {\n address tokenAddressToAdd = _initialTokenAddresses[i];\n\n addresses.push(tokenAddressToAdd);\n oracleWhiteList[tokenAddressToAdd] = _initialOracleAddresses[i];\n }\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Add an address to the whitelist\n *\n * @param _tokenAddress Token address to add to the whitelist\n * @param _oracleAddress Oracle address to add to the whitelist under _tokenAddress\n */\n function addTokenOraclePair(\n address _tokenAddress,\n address _oracleAddress\n )\n external\n onlyOwner\n timeLockUpgrade\n {\n require(\n oracleWhiteList[_tokenAddress] == address(0),\n \"OracleWhiteList.addTokenOraclePair: Token and Oracle pair already exists.\"\n );\n\n addresses.push(_tokenAddress);\n oracleWhiteList[_tokenAddress] = _oracleAddress;\n\n emit TokenOraclePairAdded(_tokenAddress, _oracleAddress);\n }\n\n /**\n * Remove a token oracle pair from the whitelist\n *\n * @param _tokenAddress Token address to remove to the whitelist\n */\n function removeTokenOraclePair(\n address _tokenAddress\n )\n external\n onlyOwner\n {\n address oracleAddress = oracleWhiteList[_tokenAddress];\n\n require(\n oracleAddress != address(0),\n \"OracleWhiteList.removeTokenOraclePair: Token Address is not current whitelisted.\"\n );\n\n addresses = addresses.remove(_tokenAddress);\n oracleWhiteList[_tokenAddress] = address(0);\n\n emit TokenOraclePairRemoved(_tokenAddress, oracleAddress);\n }\n\n /**\n * Edit oracle address associated with a token address\n *\n * @param _tokenAddress Token address to add to the whitelist\n * @param _oracleAddress Oracle address to add to the whitelist under _tokenAddress\n */\n function editTokenOraclePair(\n address _tokenAddress,\n address _oracleAddress\n )\n external\n onlyOwner\n timeLockUpgrade\n {\n require(\n oracleWhiteList[_tokenAddress] != address(0),\n \"OracleWhiteList.editTokenOraclePair: Token and Oracle pair must exist.\"\n );\n\n // Set new oracle address for passed token address\n oracleWhiteList[_tokenAddress] = _oracleAddress;\n\n emit TokenOraclePairAdded(\n _tokenAddress,\n _oracleAddress\n );\n }\n\n /**\n * Return array of all whitelisted addresses\n *\n * @return address[] Array of addresses\n */\n function validAddresses()\n external\n view\n returns (address[] memory)\n {\n return addresses;\n }\n\n /**\n * Return array of oracle addresses based on passed in token addresses \n *\n * @param _tokenAddresses Array of token addresses to get oracle addresses for\n * @return address[] Array of oracle addresses\n */\n function getOracleAddressesByToken(\n address[] calldata _tokenAddresses\n )\n external\n view\n returns (address[] memory)\n {\n // Get length of passed array\n uint256 arrayLength = _tokenAddresses.length;\n\n // Check that passed array length is greater than 0\n require(\n arrayLength > 0,\n \"OracleWhiteList.getOracleAddressesByToken: Array length must be greater than 0.\"\n );\n\n // Instantiate oracle addresses array\n address[] memory oracleAddresses = new address[](arrayLength);\n\n for (uint256 i = 0; i < arrayLength; i++) {\n // Get oracle address for token address at index i\n oracleAddresses[i] = getOracleAddressByToken(\n _tokenAddresses[i]\n );\n }\n\n return oracleAddresses; \n }\n\n /**\n * Return oracle address associated with a passed token address \n *\n * @param _tokenAddress Address of token\n * @return address Address of oracle associated with token\n */\n function getOracleAddressByToken(\n address _tokenAddress\n )\n public\n view\n returns (address)\n {\n // Require token address to have matching oracle address\n require(\n oracleWhiteList[_tokenAddress] != address(0),\n \"OracleWhiteList.getOracleAddressFromToken: No Oracle for that address.\"\n );\n\n // Return oracle address associated with token address\n return oracleWhiteList[_tokenAddress]; \n }\n\n /**\n * Verifies an array of addresses against the whitelist\n *\n * @param _tokenAddresses Array of token addresses to check if oracle exists\n * @return bool Whether all addresses in the list are whitelsited\n */\n function areValidAddresses(\n address[] calldata _tokenAddresses\n )\n external\n view\n returns (bool)\n {\n // Get length of passed array\n uint256 arrayLength = _tokenAddresses.length;\n\n // Check that passed array length is greater than 0\n require(\n arrayLength > 0,\n \"OracleWhiteList.areValidAddresses: Array length must be greater than 0.\"\n );\n\n for (uint256 i = 0; i < arrayLength; i++) {\n // Return false if token address doesn't have matching oracle address\n if (oracleWhiteList[_tokenAddresses[i]] == address(0)) {\n return false;\n }\n }\n\n return true;\n }\n\n\n}"
},
{
"path": "contracts/lib/WhiteList.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\n\nimport { Ownable } from \"openzeppelin-solidity/contracts/ownership/Ownable.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\nimport { TimeLockUpgrade } from \"set-protocol-contract-utils/contracts/lib/TimeLockUpgrade.sol\";\n\n\n/**\n * @title Whitelist\n * @author Set Protocol\n *\n * Generic whitelist for addresses\n */\ncontract WhiteList is\n Ownable,\n TimeLockUpgrade\n{\n using AddressArrayUtils for address[];\n\n /* ============ State Variables ============ */\n\n address[] public addresses;\n mapping(address => bool) public whiteList;\n\n /* ============ Events ============ */\n\n event AddressAdded(\n address _address\n );\n\n event AddressRemoved(\n address _address\n );\n\n /* ============ Constructor ============ */\n\n /**\n * Constructor function for Whitelist\n *\n * Allow initial addresses to be passed in so a separate transaction is not required for each\n *\n * @param _initialAddresses Starting set of addresses to whitelist\n */\n constructor(\n address[] memory _initialAddresses\n )\n public\n {\n // Add each of initial addresses to state\n for (uint256 i = 0; i < _initialAddresses.length; i++) {\n address addressToAdd = _initialAddresses[i];\n\n addresses.push(addressToAdd);\n whiteList[addressToAdd] = true;\n }\n }\n\n /* ============ External Functions ============ */\n\n /**\n * Add an address to the whitelist\n *\n * @param _address Address to add to the whitelist\n */\n function addAddress(\n address _address\n )\n external\n onlyOwner\n timeLockUpgrade\n {\n require(\n !whiteList[_address],\n \"WhiteList.addAddress: Address has already been whitelisted.\"\n );\n\n addresses.push(_address);\n\n whiteList[_address] = true;\n\n emit AddressAdded(\n _address\n );\n }\n\n /**\n * Remove an address from the whitelist\n *\n * @param _address Address to remove from the whitelist\n */\n function removeAddress(\n address _address\n )\n external\n onlyOwner\n {\n require(\n whiteList[_address],\n \"WhiteList.removeAddress: Address is not current whitelisted.\"\n );\n\n addresses = addresses.remove(_address);\n\n whiteList[_address] = false;\n\n emit AddressRemoved(\n _address\n );\n }\n\n /**\n * Return array of all whitelisted addresses\n *\n * @return address[] Array of addresses\n */\n function validAddresses()\n external\n view\n returns (address[] memory)\n {\n return addresses;\n }\n\n /**\n * Verifies an array of addresses against the whitelist\n *\n * @param _addresses Array of addresses to verify\n * @return bool Whether all addresses in the list are whitelsited\n */\n function areValidAddresses(\n address[] calldata _addresses\n )\n external\n view\n returns (bool)\n {\n for (uint256 i = 0; i < _addresses.length; i++) {\n if (!whiteList[_addresses[i]]) {\n return false;\n }\n }\n\n return true;\n }\n}\n"
},
{
"path": "contracts/mocks/core/CoreMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport { Core } from \"../../core/Core.sol\";\nimport { ISetToken } from \"../../core/interfaces/ISetToken.sol\";\n\n// Mock contract implementation of Core with extra functions for testing\ncontract CoreMock is Core {\n constructor(\n address _transferProxy,\n address _vault\n )\n public\n Core(_transferProxy, _vault)\n {}\n\n /*\n * Mint set token for given address.\n * Can only be called by authorized contracts.\n *\n * @param _set The address of the Set to mint\n * @param _issuer The address of the issuing account\n * @param _quantity The number of sets to attribute to issuer\n */\n function mint(\n address _set,\n address _issuer,\n uint256 _quantity\n )\n external\n {\n ISetToken(_set).mint(\n _issuer,\n _quantity\n );\n }\n\n /*\n * Burn set token for given address.\n * Can only be called by authorized contracts.\n *\n * @param _set The address of the Set to burn\n * @param _from The address of the redeeming account\n * @param _quantity The number of sets to burn from redeemer\n */\n function burn(\n address _set,\n address _from,\n uint256 _quantity\n )\n external\n {\n ISetToken(_set).burn(\n _from,\n _quantity\n );\n }\n\n function addSet(\n address _set\n )\n external\n {\n state.setTokens = state.setTokens.append(_set);\n\n state.validSets[_set] = true;\n }\n}\n\n"
},
{
"path": "contracts/mocks/core/exchange-wrappers/lib/ZeroExOrderLibraryMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { ZeroExOrderLibrary } from \"../../../../core/exchange-wrappers/lib/ZeroExOrderLibrary.sol\";\nimport { LibBytes } from \"../../../../external/0x/LibBytes.sol\";\nimport { LibOrder } from \"../../../../external/0x/Exchange/libs/LibOrder.sol\";\n\n\n// Mock class implementing internal OrderHandler methods\ncontract ZeroExOrderLibraryMock {\n using SafeMath for uint256;\n using LibBytes for bytes;\n\n function parseOrderHeader(\n bytes calldata _ordersData,\n uint256 _offset\n )\n external\n pure\n returns (uint256, uint256)\n {\n ZeroExOrderLibrary.OrderHeader memory header = ZeroExOrderLibrary.parseOrderHeader(\n _ordersData,\n _offset\n );\n\n return (header.signatureLength, header.fillAmount);\n }\n\n function parseZeroExOrder(\n bytes calldata _ordersData,\n uint256 _offset\n )\n external\n pure\n returns (address[4] memory, uint256[6] memory, bytes memory, bytes memory)\n {\n ZeroExOrderLibrary.OrderHeader memory header = ZeroExOrderLibrary.parseOrderHeader(\n _ordersData,\n _offset\n );\n\n LibOrder.Order memory order = ZeroExOrderLibrary.parseZeroExOrder(\n _ordersData,\n _offset.add(header.signatureLength).add(64)\n );\n\n return (\n [\n order.makerAddress,\n order.takerAddress,\n order.feeRecipientAddress,\n order.senderAddress\n ],\n [\n order.makerAssetAmount,\n order.takerAssetAmount,\n order.makerFee,\n order.takerFee,\n order.expirationTimeSeconds,\n order.salt\n ],\n order.makerAssetData,\n order.takerAssetData\n );\n }\n}\n"
},
{
"path": "contracts/mocks/core/fee-calculators/FeeCalculatorMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { IFeeCalculator } from \"../../../core/interfaces/IFeeCalculator.sol\";\n\ncontract FeeCalculatorMock {\n uint256 public feeValue;\n\n function testInitialize(\n address _feeCalculator,\n bytes calldata _feeCalculatorData\n )\n external\n {\n return IFeeCalculator(_feeCalculator).initialize(_feeCalculatorData);\n }\n\n function testGetFee(\n address _feeCalculator\n )\n external\n view\n returns(uint256)\n {\n return IFeeCalculator(_feeCalculator).getFee();\n }\n\n function testUpdateAndGetFee(\n address _feeCalculator\n )\n external\n {\n feeValue = IFeeCalculator(_feeCalculator).updateAndGetFee();\n }\n}\n"
},
{
"path": "contracts/mocks/core/fee-calculators/FixedFeeCalculatorMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { FixedFeeCalculator } from \"../../../core/fee-calculators/FixedFeeCalculator.sol\";\n\ncontract FixedFeeCalculatorMock is FixedFeeCalculator {\n bool public isCalled;\n\n // Override updateAndGetFee to test\n function updateAndGetFee()\n external\n returns(uint256)\n {\n isCalled = true;\n\n return fees[msg.sender];\n }\n}\n"
},
{
"path": "contracts/mocks/core/fee-calculators/RebalancingSetFeeMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport { IFeeCalculator } from \"../../../core/interfaces/IFeeCalculator.sol\";\nimport { ISetToken } from \"../../../core/interfaces/ISetToken.sol\";\n\n\ncontract RebalancingSetFeeMock {\n uint256 public unitShares;\n uint256 public naturalUnit;\n ISetToken public currentSet;\n IFeeCalculator public feeCalculator;\n\n uint256 public fee;\n\n constructor(\n uint256 _unitShares,\n uint256 _naturalUnit,\n ISetToken _currentSet,\n IFeeCalculator _feeCalculator\n )\n\t\tpublic\n\t{\n unitShares = _unitShares;\n naturalUnit = _naturalUnit;\n currentSet = _currentSet;\n feeCalculator = _feeCalculator;\n }\n\n function initialize(\n bytes calldata _feeCallData\n )\n external\n {\n feeCalculator.initialize(_feeCallData);\n }\n\n function getFee()\n external\n view\n returns (uint256)\n {\n return feeCalculator.getFee();\n }\n\n function updateAndGetFee()\n external\n {\n fee = feeCalculator.updateAndGetFee();\n }\n\n function adjustFee(bytes calldata _newFeePercentage)\n external\n {\n feeCalculator.adjustFee(_newFeePercentage);\n }\n}"
},
{
"path": "contracts/mocks/core/lib/ConstantAuctionPriceCurve.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { RebalancingLibrary } from \"../../../core/lib/RebalancingLibrary.sol\";\n\n/**\n * @title ConstantAuctionPriceCurve\n * @author Set Protocol\n *\n * Contract used in rebalancing auction testing to return consistent price\n *\n */\n\ncontract ConstantAuctionPriceCurve {\n using SafeMath for uint256;\n\n uint256 constant public MIN_PIVOT_PRICE_DIVISOR = 2;\n uint256 constant public MAX_PIVOT_PRICE_NUMERATOR = 5;\n\n uint256 public priceNumerator;\n uint256 public priceDivisor;\n\n /*\n * Declare price you want this library to return when queried\n *\n * @param _priceNumerator The priceNumerator you want this library to always return\n * @param _priceDivisor The priceDivisor you want this library to always return\n */\n constructor(\n uint256 _priceNumerator,\n uint256 _priceDivisor\n )\n public\n {\n // Set price to be returned by library\n priceNumerator = _priceNumerator;\n priceDivisor = _priceDivisor;\n }\n\n /*\n * Validate any auction parameters that have library-specific restrictions\n *\n * @param _auctionPriceParameters Struct containing relevant auction price parameters\n */\n function validateAuctionPriceParameters(\n RebalancingLibrary.AuctionPriceParameters memory _auctionPriceParameters\n )\n public\n view\n {\n // Require pivot price to be greater than 0.5 * price denominator\n // Equivalent to oldSet/newSet = 0.5\n require(\n _auctionPriceParameters.auctionPivotPrice > priceDivisor.div(MIN_PIVOT_PRICE_DIVISOR),\n \"LinearAuctionPriceCurve.validateAuctionPriceParameters: Pivot price too low\"\n );\n // Require pivot price to be less than 5 * price denominator\n // Equivalent to oldSet/newSet = 5\n require(\n _auctionPriceParameters.auctionPivotPrice < priceDivisor.mul(MAX_PIVOT_PRICE_NUMERATOR),\n \"LinearAuctionPriceCurve.validateAuctionPriceParameters: Pivot price too high\"\n );\n }\n\n /*\n * Calculate the current priceRatio for an auction given defined price and time parameters\n *\n * -- Unused _auctionPriceParameters param containing relevant auction price parameters --\n * @return uint256 The auction price numerator\n * @return uint256 The auction price denominator\n */\n function getCurrentPrice(\n RebalancingLibrary.AuctionPriceParameters memory\n )\n public\n view\n returns (uint256, uint256)\n {\n return (priceNumerator, priceDivisor);\n }\n}\n"
},
{
"path": "contracts/mocks/core/lib/CoreIssuanceLibraryMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { CoreIssuanceLibrary } from \"../../../core/lib/CoreIssuanceLibrary.sol\";\n\n// Mock contract implementation of CoreIssuanceLibraryMock functions\ncontract CoreIssuanceLibraryMock {\n function testCalculateRequiredComponentQuantities(\n uint256[] memory _componentUnits,\n uint256 _naturalUnit,\n uint256 _quantity\n )\n public\n pure\n returns (uint256[] memory)\n {\n return CoreIssuanceLibrary.calculateRequiredComponentQuantities(\n _componentUnits,\n _naturalUnit,\n _quantity\n );\n }\n}\n"
},
{
"path": "contracts/mocks/core/lib/ExchangeIssuanceLibraryMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { ExchangeIssuanceLibrary } from \"../../../core/modules/lib/ExchangeIssuanceLibrary.sol\";\n\n\n// Mock class of ExchangeIssuanceLibrary\ncontract ExchangeIssuanceLibraryMock {\n using SafeMath for uint256;\n\n function testValidateQuantity(\n address _set,\n uint256 _quantity\n )\n external\n view\n {\n ExchangeIssuanceLibrary.validateQuantity(\n _set,\n _quantity\n );\n }\n\n function testValidatePostExchangeReceiveTokenBalances(\n address _vault,\n address[] memory _receiveTokens,\n uint256[] memory _requiredBalances,\n address _userToCheck\n )\n public\n view\n {\n ExchangeIssuanceLibrary.validatePostExchangeReceiveTokenBalances(\n _vault,\n _receiveTokens,\n _requiredBalances,\n _userToCheck\n );\n }\n\n function testValidateReceiveTokens(\n address[] memory _receiveTokens,\n uint256[] memory _receiveTokenAmounts\n )\n public\n view \n {\n ExchangeIssuanceLibrary.validateReceiveTokens(\n _receiveTokens,\n _receiveTokenAmounts\n );\n }\n\n function testValidateSendTokenParams(\n address _core,\n uint8[] memory _sendTokenExchangeIds,\n address[] memory _sendTokens,\n uint256[] memory _sendTokenAmounts\n )\n public\n view \n {\n ExchangeIssuanceLibrary.validateSendTokenParams(\n _core,\n _sendTokenExchangeIds,\n _sendTokens,\n _sendTokenAmounts\n );\n }\n}\n"
},
{
"path": "contracts/mocks/core/lib/RebalanceMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { IRebalancingSetToken } from \"../../../core/interfaces/IRebalancingSetToken.sol\";\nimport { Rebalance } from \"../../../core/lib/Rebalance.sol\";\n\ncontract RebalanceMock {\n function getTokenFlows(\n IRebalancingSetToken _rebalancingSetToken,\n uint256 _quantity\n )\n external\n view\n returns(address[] memory, uint256[] memory, uint256[] memory)\n {\n return Rebalance.getTokenFlows(\n _rebalancingSetToken,\n _quantity\n );\n }\n}\n"
},
{
"path": "contracts/mocks/core/lib/SetMathMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SetMath } from \"../../../core/lib/SetMath.sol\";\n\ncontract SetMathMock {\n\n function setToComponent(\n uint256 _setQuantity,\n uint256 _unit,\n uint256 _naturalUnit\n )\n public\n view\n returns(uint256)\n {\n return SetMath.setToComponent(\n _setQuantity,\n _unit,\n _naturalUnit\n );\n }\n\n function componentToSet(\n uint256 _componentQuantity,\n uint256 _unit,\n uint256 _naturalUnit\n )\n public\n view\n returns(uint256)\n {\n return SetMath.componentToSet(\n _componentQuantity,\n _unit,\n _naturalUnit\n );\n }\n}\n"
},
{
"path": "contracts/mocks/core/lib/SetTokenLibraryMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { ICore } from \"../../../core/interfaces/ICore.sol\";\nimport { SetTokenLibrary } from \"../../../core/lib/SetTokenLibrary.sol\";\n\n// Mock class of SetTokenLibrary\ncontract SetTokenLibraryMock {\n using SafeMath for uint256;\n\n function testValidateTokensAreComponents(\n address _set,\n address[] memory _tokens\n )\n public\n view\n {\n SetTokenLibrary.validateTokensAreComponents(\n _set,\n _tokens\n );\n }\n\n function testIsMultipleOfSetNaturalUnit(\n address _set,\n uint256 _quantity\n )\n external\n view\n {\n SetTokenLibrary.isMultipleOfSetNaturalUnit(\n _set,\n _quantity\n );\n }\n\n function testRequireValidSet(\n ICore _core,\n address _set\n )\n external\n view\n {\n SetTokenLibrary.requireValidSet(\n _core,\n _set\n );\n }\n\n function testGetSetDetails(\n address _set\n )\n public\n view\n returns (\n uint256, /* naturalUnit */\n address[] memory, /* components */\n uint256[] memory /* units */\n )\n {\n SetTokenLibrary.SetDetails memory setToken = SetTokenLibrary.getSetDetails(_set);\n\n return (\n setToken.naturalUnit,\n setToken.components,\n setToken.units\n );\n }\n}\n"
},
{
"path": "contracts/mocks/core/lib/UpdatableConstantAuctionPriceCurve.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { ConstantAuctionPriceCurve } from \"./ConstantAuctionPriceCurve.sol\";\n\n/**\n * @title UpdatableConstantAuctionPriceCurve\n * @author Set Protocol\n *\n * Contract used in rebalancing auction testing to return consistent price.\n * !!!!!!!!!!!!! DO NOT DEPLOY !!!!!!!!!!!!!\n *\n */\n\ncontract UpdatableConstantAuctionPriceCurve is ConstantAuctionPriceCurve {\n\n constructor(\n uint256 _priceNumerator,\n uint256 _priceDivisor\n )\n public\n ConstantAuctionPriceCurve(\n _priceNumerator,\n _priceDivisor\n )\n {}\n\n /*\n * Update constant auction price\n *\n * @param _newPrice Price to update to\n */\n function updatePrice(\n uint256 _newPrice\n )\n public\n {\n priceNumerator = _newPrice;\n }\n}\n"
},
{
"path": "contracts/mocks/core/liquidators/LiquidatorProxy.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ILiquidator } from \"../../../core/interfaces/ILiquidator.sol\";\nimport { ISetToken } from \"../../../core/interfaces/ISetToken.sol\";\nimport { Rebalance } from \"../../../core/lib/Rebalance.sol\";\nimport { TWAPAuction } from \"../../../core/liquidators/twap-impl/TWAPAuction.sol\";\n\n\n// Mock contract implementation of Auction with extra functions for testing\ncontract LiquidatorProxy {\n ILiquidator public liquidator;\n\n uint256[] private inflow;\n uint256[] private outflow;\n address[] private combinedTokenArray;\n\n uint256 public rebalanceFailPeriod;\n\n constructor(\n ILiquidator _liquidator\n )\n public\n {\n liquidator = _liquidator;\n }\n\n function startRebalance(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n bytes calldata _liquidatorData\n )\n external\n {\n liquidator.startRebalance(\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity,\n _liquidatorData\n );\n }\n\n function settleRebalance() external {\n liquidator.settleRebalance();\n }\n\n function endFailedRebalance() external {\n liquidator.endFailedRebalance();\n }\n\n function placeBid(uint256 _quantity) external {\n Rebalance.TokenFlow memory tokenFlow = liquidator.placeBid(_quantity);\n\n combinedTokenArray = tokenFlow.addresses;\n inflow = tokenFlow.inflow;\n outflow = tokenFlow.outflow;\n }\n\n function getBidPrice(\n address _set,\n uint256 _quantity\n )\n external\n view\n returns (Rebalance.TokenFlow memory)\n {\n return liquidator.getBidPrice(_set, _quantity);\n }\n\n function getInflow() external view returns(uint256[] memory) {\n return inflow;\n }\n\n function getOutflow() external view returns(uint256[] memory) {\n return outflow;\n }\n\n function getCombinedTokenArray() external view returns(address[] memory) {\n return combinedTokenArray;\n }\n\n function setAuctionFailPeriod(uint256 _newFailPeriod) external {\n rebalanceFailPeriod = _newFailPeriod;\n }\n}\n\n"
},
{
"path": "contracts/mocks/core/liquidators/impl/AuctionGettersMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Auction } from \"../../../../core/liquidators/impl/Auction.sol\";\nimport { AuctionGetters } from \"../../../../core/liquidators/impl/AuctionGetters.sol\";\n\n\n// Mock contract implementation of AuctionGetters with extra functions for testing\ncontract AuctionGettersMock is AuctionGetters {\n\n Auction.Setup public auctionState;\n\n function auction(address _set) internal view returns(Auction.Setup storage) {\n return auctionState;\n }\n\n function setState(Auction.Setup memory _state) public {\n auctionState = _state;\n }\n}"
},
{
"path": "contracts/mocks/core/liquidators/impl/AuctionMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\n\nimport { Auction } from \"../../../../core/liquidators/impl/Auction.sol\";\nimport { ISetToken } from \"../../../../core/interfaces/ISetToken.sol\";\nimport { IOracleWhiteList } from \"../../../../core/interfaces/IOracleWhiteList.sol\";\n\n// Mock contract implementation of Auction with extra functions for testing\ncontract AuctionMock is Auction {\n Auction.Setup public auction;\n\n function initializeAuction(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity\n )\n external\n {\n super.initializeAuction(auction, _currentSet, _nextSet, _startingCurrentSetQuantity);\n\n auction.minimumBid = calculateMinimumBid(auction, _currentSet, _nextSet);\n }\n\n function reduceRemainingCurrentSets(\n uint256 _quantity\n )\n external\n {\n super.reduceRemainingCurrentSets(auction, _quantity);\n }\n\n function validateBidQuantity(\n uint256 _quantity\n )\n external\n {\n super.validateBidQuantity(auction, _quantity);\n }\n\n function validateAuctionCompletion() external {\n super.validateAuctionCompletion(auction);\n }\n\n function isAuctionActive() external view returns(bool) {\n return super.isAuctionActive(auction);\n }\n\n function combinedTokenArray() external view returns(address[] memory) {\n return auction.combinedTokenArray;\n }\n\n function combinedCurrentSetUnits() external view returns(uint256[] memory) {\n return auction.combinedCurrentSetUnits;\n }\n\n function combinedNextSetUnits() external view returns(uint256[] memory) {\n return auction.combinedNextSetUnits;\n }\n\n function calculateMinimumBid(\n Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns (uint256)\n {\n return Math.max(\n _currentSet.naturalUnit(),\n _nextSet.naturalUnit()\n );\n }\n}\n\n"
},
{
"path": "contracts/mocks/core/liquidators/impl/LinearAuctionMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { CommonMath } from \"set-protocol-contract-utils/contracts/lib/CommonMath.sol\";\n\nimport { Auction } from \"../../../../core/liquidators/impl/Auction.sol\";\nimport { LinearAuction } from \"../../../../core/liquidators/impl/LinearAuction.sol\";\nimport { IOracleWhiteList } from \"../../../../core/interfaces/IOracleWhiteList.sol\";\nimport { ISetToken } from \"../../../../core/interfaces/ISetToken.sol\";\nimport { Rebalance } from \"../../../../core/lib/Rebalance.sol\";\nimport { SetUSDValuation } from \"../../../../core/liquidators/impl/SetUSDValuation.sol\";\n\ncontract LinearAuctionMock is LinearAuction {\n using CommonMath for uint256;\n\n LinearAuction.State public auction;\n IOracleWhiteList public oracleWhiteList;\n\n uint256 public rangeStart; // Percentage below FairValue to begin auction at\n uint256 public rangeEnd; // Percentage above FairValue to end auction at\n\n constructor(\n IOracleWhiteList _oracleWhiteList,\n uint256 _auctionPeriod,\n uint256 _rangeStart,\n uint256 _rangeEnd\n )\n public\n LinearAuction(\n _auctionPeriod\n )\n {\n oracleWhiteList = _oracleWhiteList;\n rangeStart = _rangeStart;\n rangeEnd = _rangeEnd;\n }\n\n function calculateStartPrice(\n Auction.Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns(uint256)\n {\n uint256 fairValue = calculateFairValue(_currentSet, _nextSet);\n uint256 startRange = fairValue.mul(rangeStart).div(100);\n return fairValue.sub(startRange);\n }\n\n function calculateEndPrice(\n Auction.Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns(uint256)\n {\n uint256 fairValue = calculateFairValue(_currentSet, _nextSet);\n uint256 endRange = fairValue.mul(rangeEnd).div(100);\n return fairValue.add(endRange);\n }\n\n /**\n * Calculates the fair value based on the USD values of the next and current Sets.\n * Returns a scaled value\n */\n function calculateFairValue(\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns (uint256)\n {\n uint256 currentSetUSDValue = calculateUSDValueOfSet(_currentSet);\n uint256 nextSetUSDValue = calculateUSDValueOfSet(_nextSet);\n\n return nextSetUSDValue.scale().div(currentSetUSDValue);\n }\n\n function initializeLinearAuction(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity\n )\n external\n {\n super.initializeLinearAuction(auction, _currentSet, _nextSet, _startingCurrentSetQuantity);\n }\n\n function reduceRemainingCurrentSets(\n uint256 _quantity\n )\n external\n {\n super.reduceRemainingCurrentSets(auction.auction, _quantity);\n }\n\n function hasAuctionFailed() external view returns(bool) {\n return super.hasAuctionFailed(auction);\n }\n\n function getPrice() external view returns(uint256) {\n return super.getPrice(auction);\n }\n\n function getTokenFlow(\n uint256 _quantity\n ) external view returns (Rebalance.TokenFlow memory) {\n return super.getTokenFlow(auction, _quantity);\n }\n\n /**\n * Calculate USD value of passed Set\n *\n * @param _set Instance of SetToken\n * @return USDValue USD Value of the Set Token\n */\n function calculateUSDValueOfSet(ISetToken _set) internal view returns(uint256) {\n return SetUSDValuation.calculateSetTokenDollarValue(_set, oracleWhiteList);\n }\n\n function calculateMinimumBid(\n Setup storage _auction,\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n internal\n view\n returns (uint256)\n {\n return Math.max(\n _currentSet.naturalUnit(),\n _nextSet.naturalUnit()\n );\n }\n}\n\n"
},
{
"path": "contracts/mocks/core/liquidators/impl/SetUSDValuationMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport { SetUSDValuation } from \"../../../../core/liquidators/impl/SetUSDValuation.sol\";\nimport { ISetToken } from \"../../../../core/interfaces/ISetToken.sol\";\nimport { IOracleWhiteList } from \"../../../../core/interfaces/IOracleWhiteList.sol\";\n\ncontract SetUSDValuationMock {\n\n function calculateSetTokenDollarValue(\n ISetToken _set,\n IOracleWhiteList _oracleWhitelist\n )\n external\n returns(uint256)\n {\n return SetUSDValuation.calculateSetTokenDollarValue(_set, _oracleWhitelist);\n }\n\n function calculateTokenAllocationAmountUSD(\n uint256 _tokenPrice,\n uint256 _naturalUnit,\n uint256 _unit,\n uint256 _tokenDecimal\n )\n external\n returns(uint256)\n {\n return SetUSDValuation.calculateTokenAllocationAmountUSD(\n _tokenPrice,\n _naturalUnit,\n _unit,\n _tokenDecimal\n );\n }\n\n}\n\n"
},
{
"path": "contracts/mocks/core/liquidators/impl/TwoAssetPriceBoundedLinearAuctionMock.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20Detailed } from \"openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol\";\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { IOracle } from \"set-protocol-oracles/contracts/meta-oracles/interfaces/IOracle.sol\";\n\nimport { LinearAuction } from \"../../../../core/liquidators/impl/LinearAuction.sol\";\nimport { ISetToken } from \"../../../../core/interfaces/ISetToken.sol\";\nimport { IOracleWhiteList } from \"../../../../core/interfaces/IOracleWhiteList.sol\";\nimport { TwoAssetPriceBoundedLinearAuction } from \"../../../../core/liquidators/impl/TwoAssetPriceBoundedLinearAuction.sol\";\n\n/**\n * @title TwoAssetPriceBoundedLinearAuction\n * @author Set Protocol\n *\n */\ncontract TwoAssetPriceBoundedLinearAuctionMock is TwoAssetPriceBoundedLinearAuction {\n\n\tLinearAuction.State public auctionInfo;\n\n constructor(\n IOracleWhiteList _oracleWhiteList,\n uint256 _auctionPeriod,\n uint256 _rangeStart,\n uint256 _rangeEnd\n )\n public\n TwoAssetPriceBoundedLinearAuction(\n _oracleWhiteList,\n _auctionPeriod,\n _rangeStart,\n _rangeEnd\n )\n {}\n\n // To test\n function validateTwoAssetPriceBoundedAuctionMock(ISetToken _currentSet,ISetToken _nextSet) external view {\n validateTwoAssetPriceBoundedAuction(_currentSet, _nextSet);\n }\n\n function calculateMinimumBid(ISetToken _currentSet, ISetToken _nextSet) external returns(uint256) {\n auctionInfo.auction.maxNaturalUnit = Math.max(\n _currentSet.naturalUnit(),\n _nextSet.naturalUnit()\n );\n\n return super.calculateMinimumBid(auctionInfo.auction, _currentSet, _nextSet);\n }\n\n function calculateStartPriceMock() external view returns(uint256) { \n ISetToken currentSet = ISetToken(address(0));\n ISetToken nextSet = ISetToken(address(0));\n return super.calculateStartPrice(auctionInfo.auction, currentSet, nextSet);\n }\n\n function calculateEndPriceMock() external view returns(uint256) { \n ISetToken currentSet = ISetToken(address(0));\n ISetToken nextSet = ISetToken(address(0));\n return super.calculateEndPrice(auctionInfo.auction, currentSet, nextSet);\n }\n\n function parameterizeAuction(\n \taddress[] calldata _combinedTokenArray,\n \tuint256[] calldata _combinedCurrentSetUnits,\n \tuint256[] calldata _combinedNextSetUnits\n )\n \texternal\n {\n \tauctionInfo.auction.combinedTokenArray = _combinedTokenArray;\n \tauctionInfo.auction.combinedCurrentSetUnits = _combinedCurrentSetUnits;\n \tauctionInfo.auction.combinedNextSetUnits = _combinedNextSetUnits;\n }\n\n function getCombinedTokenArray()\n \texternal\n \tview\n \treturns(address[] memory)\n {\n \treturn auctionInfo.auction.combinedTokenArray;\n }\n}"
},
{
"path": "contracts/mocks/core/liquidators/twap-impl/TWAPAuctionCaller.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ISetToken } from \"../../../../core/interfaces/ISetToken.sol\";\nimport { TWAPAuction } from \"../../../../core/liquidators/twap-impl/TWAPAuction.sol\";\n\n\n// Mock contract implementation of Auction with extra functions for testing\ncontract TWAPAuctionCaller {\n ITWAPAuction public twapAuction;\n uint256 public rebalanceFailPeriod;\n\n constructor(\n ITWAPAuction _twapAuction,\n uint256 _rebalanceFailPeriod\n )\n public\n {\n twapAuction = _twapAuction;\n rebalanceFailPeriod = _rebalanceFailPeriod;\n }\n\n function validateLiquidatorData(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n uint256 _chunkSizeValue,\n uint256 _chunkAuctionPeriod\n )\n public\n {\n twapAuction.testValidateLiquidatorData(\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity,\n _chunkSizeValue,\n _chunkAuctionPeriod\n );\n }\n}\n\ninterface ITWAPAuction{\n function testValidateLiquidatorData(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n uint256 _chunkSizeValue,\n uint256 _chunkAuctionPeriod\n )\n external;\n}"
},
{
"path": "contracts/mocks/core/liquidators/twap-impl/TWAPAuctionGettersMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Auction } from \"../../../../core/liquidators/impl/Auction.sol\";\nimport { TWAPAuction } from \"../../../../core/liquidators/twap-impl/TWAPAuction.sol\";\nimport { TWAPAuctionGetters } from \"../../../../core/liquidators/twap-impl/TWAPAuctionGetters.sol\";\n\n\n// Mock contract implementation of AuctionGetters with extra functions for testing\ncontract TWAPAuctionGettersMock is TWAPAuctionGetters {\n struct TestTWAPGetters {\n uint256 orderSize;\n uint256 orderRemaining;\n uint256 lastChunkAuctionEnd;\n uint256 chunkAuctionPeriod;\n uint256 chunkSize;\n uint256 remainingCurrentSets;\n }\n\n Auction.Setup public auctionState;\n TWAPAuction.TWAPState public twapAuctionState;\n\n function setState(TestTWAPGetters memory _state) public {\n twapAuctionState.orderSize = _state.orderSize;\n twapAuctionState.orderRemaining = _state.orderRemaining;\n twapAuctionState.lastChunkAuctionEnd = _state.lastChunkAuctionEnd;\n twapAuctionState.chunkAuctionPeriod = _state.chunkAuctionPeriod;\n twapAuctionState.chunkSize = _state.chunkSize;\n auctionState.remainingCurrentSets = _state.remainingCurrentSets;\n }\n\n function twapAuction(address _set) internal view returns(TWAPAuction.TWAPState storage) {\n return twapAuctionState;\n }\n\n function auction(address _set) internal view returns(Auction.Setup storage) {\n return auctionState;\n }\n}"
},
{
"path": "contracts/mocks/core/liquidators/twap-impl/TWAPAuctionMock.sol",
"content": "/*\n Copyright 2020 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { BoundsLibrary } from \"set-protocol-contract-utils/contracts/lib/BoundsLibrary.sol\";\n\nimport { ISetToken } from \"../../../../core/interfaces/ISetToken.sol\";\nimport { IOracleWhiteList } from \"../../../../core/interfaces/IOracleWhiteList.sol\";\nimport { TWAPAuction } from \"../../../../core/liquidators/twap-impl/TWAPAuction.sol\";\n\n\n/**\n * @title TwoAssetPriceBoundedLinearAuction\n * @author Set Protocol\n *\n */\ncontract TWAPAuctionMock is TWAPAuction {\n\n TWAPAuction.TWAPState public twapState;\n\n constructor(\n IOracleWhiteList _oracleWhiteList,\n uint256 _auctionPeriod,\n uint256 _rangeStart,\n uint256 _rangeEnd,\n TWAPAuction.AssetPairVolumeBounds[] memory _assetPairVolumeBounds\n )\n public\n TWAPAuction(\n _oracleWhiteList,\n _auctionPeriod,\n _rangeStart,\n _rangeEnd,\n _assetPairVolumeBounds\n )\n {}\n\n function testInitializeTWAPAuction(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n uint256 _chunkSizeValue,\n uint256 _chunkAuctionPeriod\n )\n external\n {\n initializeTWAPAuction(\n twapState,\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity,\n _chunkSizeValue,\n _chunkAuctionPeriod\n );\n }\n\n function testAuctionNextChunk()\n external\n {\n auctionNextChunk(twapState);\n }\n\n function testParseLiquidatorData(\n bytes calldata _liquidatorData\n )\n external\n pure\n returns (uint256, uint256)\n {\n return TWAPAuction.parseLiquidatorData(_liquidatorData);\n }\n\n function testValidateLiquidatorData(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 _startingCurrentSetQuantity,\n uint256 _chunkSizeValue,\n uint256 _chunkAuctionPeriod\n )\n external\n {\n TWAPAuction.validateLiquidatorData(\n _currentSet,\n _nextSet,\n _startingCurrentSetQuantity,\n _chunkSizeValue,\n _chunkAuctionPeriod\n );\n }\n\n function testValidateNextChunkAuction()\n external\n {\n TWAPAuction.validateNextChunkAuction(twapState);\n }\n\n function testGetVolumeBoundsFromCollateral(\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n external\n view\n returns (BoundsLibrary.Bounds memory)\n {\n return TWAPAuction.getVolumeBoundsFromCollateral(_currentSet, _nextSet);\n }\n\n /* ============ Setters ============ */\n function setRemainingCurrentSets(\n uint256 _value\n )\n external\n {\n twapState.chunkAuction.auction.remainingCurrentSets = _value;\n }\n\n function setLastChunkAuctionEnd(\n uint256 _value\n )\n external\n {\n twapState.lastChunkAuctionEnd = _value;\n }\n}"
},
{
"path": "contracts/mocks/core/liquidators/utils/LiquidatorUtilsMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ISetToken } from \"../../../../core/interfaces/ISetToken.sol\";\nimport { IOracleWhiteList } from \"../../../../core/interfaces/IOracleWhiteList.sol\";\nimport { LiquidatorUtils } from \"../../../../core/liquidators/utils/LiquidatorUtils.sol\";\n\n\n// Mock contract implementation of LiquidatorUtils\ncontract LiquidatorUtilsMock {\n\n function testCalculateRebalanceVolume(\n ISetToken _currentSet,\n ISetToken _nextSet,\n IOracleWhiteList _oracleWhiteList,\n uint256 _currentSetQuantity\n )\n external\n view\n returns (uint256)\n {\n return LiquidatorUtils.calculateRebalanceVolume(\n _currentSet,\n _nextSet,\n _oracleWhiteList,\n _currentSetQuantity\n );\n }\n\n function testCalculateAssetAllocation(\n ISetToken _setToken,\n IOracleWhiteList _oracleWhiteList,\n address _asset\n )\n external\n view\n returns (uint256)\n {\n return LiquidatorUtils.calculateAssetAllocation(\n _setToken,\n _oracleWhiteList,\n _asset\n );\n }\n}"
},
{
"path": "contracts/mocks/core/modules/RebalanceAuctionModuleMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport { RebalanceAuctionModule } from \"../../../core/modules/RebalanceAuctionModule.sol\";\nimport { IRebalancingSetToken } from \"../../../core/interfaces/IRebalancingSetToken.sol\";\n\ncontract RebalanceAuctionModuleMock is\n\tRebalanceAuctionModule\n{\n constructor(\n address _core,\n address _vault\n )\n public\n RebalanceAuctionModule(_core, _vault)\n {}\n\n\tfunction placeBid(\n address _set,\n uint256 _quantity\n )\n external\n {\n IRebalancingSetToken rebalancingSetToken = IRebalancingSetToken(_set);\n\n // Issue set token\n rebalancingSetToken.placeBid(\n _quantity\n );\n }\n\n function calculateExecutionQuantityExternal(\n address _rebalancingSetToken,\n uint256 _quantity,\n bool _allowPartialFill\n )\n external\n returns (uint256)\n {\n return calculateExecutionQuantity(\n _rebalancingSetToken,\n _quantity,\n _allowPartialFill\n );\n }\n}\n\n"
},
{
"path": "contracts/mocks/core/modules/lib/RebalancingSetIssuanceMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport { RebalancingSetIssuance } from \"../../../../core/modules/lib/RebalancingSetIssuance.sol\";\nimport { ModuleCoreState } from \"../../../../core/modules/lib/ModuleCoreState.sol\";\n\ncontract RebalancingSetIssuanceMock is\n\tRebalancingSetIssuance\n{\n constructor(\n address _core,\n address _vault\n )\n public\n ModuleCoreState(_core, _vault)\n {}\n\n function validateWETHIsAComponentOfSetMock(\n address _setAddress,\n address _wrappedEtherAddress\n )\n external\n {\n \tvalidateWETHIsAComponentOfSet(_setAddress, _wrappedEtherAddress);\n }\n\n\tfunction validateRebalancingSetIssuanceMock(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity\n )\n \texternal\n\t{\n\t\tvalidateRebalancingSetIssuance(_rebalancingSetAddress, _rebalancingSetQuantity);\n\t}\n\n\tfunction getBaseSetIssuanceRequiredQuantityMock(\n address _rebalancingSetAddress,\n uint256 _rebalancingSetQuantity\n )\n \texternal\n \treturns (uint256)\n\t{\n\t\treturn getBaseSetIssuanceRequiredQuantity(_rebalancingSetAddress, _rebalancingSetQuantity);\n\t}\n \n function getBaseSetRedeemQuantityMock(\n address _baseSetAddress\n )\n external\n returns (uint256)\n {\n \treturn getBaseSetRedeemQuantity(_baseSetAddress);\n }\n\n function returnExcessBaseSetFromContractMock(\n \taddress _baseSetAddress,\n \taddress _transferProxyAddress,\n bool _keepChangeInVault\n\t)\n\t\texternal\n\t{\n\t\treturnExcessBaseSetFromContract(_baseSetAddress, _transferProxyAddress, _keepChangeInVault);\n\t}\n\n\tfunction returnExcessBaseSetInVaultMock(\n address _baseSetAddress,\n bool _keepChangeInVault\n )\n external\n {\n \treturnExcessBaseSetInVault(_baseSetAddress, _keepChangeInVault);\n }\n}\n\n"
},
{
"path": "contracts/mocks/core/modules/lib/TokenFlushMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport { ICore } from \"../../../../core/interfaces/ICore.sol\";\nimport { ISetToken } from \"../../../../core/interfaces/ISetToken.sol\";\nimport { ITransferProxy } from \"../../../../core/interfaces/ITransferProxy.sol\";\nimport { IVault } from \"../../../../core/interfaces/IVault.sol\";\nimport { TokenFlush } from \"../../../../core/modules/lib/TokenFlush.sol\";\nimport { ModuleCoreStateV2 } from \"../../../../core/modules/lib/ModuleCoreStateV2.sol\";\n\ncontract TokenFlushMock is\n ModuleCoreStateV2,\n TokenFlush\n{\n constructor(\n ICore _core,\n IVault _vault,\n ITransferProxy _transferProxy\n )\n public\n ModuleCoreStateV2(_core, _vault, _transferProxy)\n {}\n\n function returnExcessBaseSetFromContractMock(\n \taddress _baseSetAddress,\n \taddress _returnAddress,\n bool _keepChangeInVault\n\t)\n\t\texternal\n\t{\n\t\treturnExcessBaseSetFromContract(_baseSetAddress, _returnAddress, _keepChangeInVault);\n\t}\n\n\tfunction returnExcessBaseSetInVaultMock(\n address _baseSetAddress,\n address _returnAddress,\n bool _keepChangeInVault\n )\n external\n {\n \treturnExcessBaseSetInVault(_baseSetAddress, _returnAddress, _keepChangeInVault);\n }\n\n function returnExcessComponentsFromContractMock(\n ISetToken _baseSetToken,\n address _returnAddress\n )\n external\n {\n returnExcessComponentsFromContract(_baseSetToken, _returnAddress);\n }\n\n function returnExcessComponentsFromVaultMock(\n ISetToken _baseSetToken,\n address _returnAddress\n )\n external\n {\n returnExcessComponentsFromVault(_baseSetToken, _returnAddress);\n }\n}\n\n"
},
{
"path": "contracts/mocks/lib/ERC20WrapperMock.sol",
"content": "pragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ERC20Wrapper } from \"../../lib/ERC20Wrapper.sol\";\n\n// Mock contract implementation of CommonMathMock functions\ncontract ERC20WrapperMock {\n function allowance(\n address _token,\n address _owner,\n address _spender\n )\n external\n view\n returns (uint256)\n {\n return ERC20Wrapper.allowance(_token, _owner, _spender);\n }\n\n function approve(\n address _token,\n address _spender,\n uint256 _quantity\n )\n external\n {\n ERC20Wrapper.approve(_token, _spender, _quantity);\n }\n\n function ensureAllowance(\n address _token,\n address _owner,\n address _spender,\n uint256 _quantity\n )\n external\n {\n ERC20Wrapper.ensureAllowance(_token, _owner, _spender, _quantity);\n }\n}\n"
},
{
"path": "contracts/mocks/supplementary/ISocialAllocator.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ISetToken } from \"../../core/interfaces/ISetToken.sol\";\n\n/**\n * @title ISocialAllocator\n * @author Set Protocol\n *\n * Interface for interacting with SocialAllocator contracts\n */\ninterface ISocialAllocator {\n\n /*\n * Determine the next allocation to rebalance into.\n *\n * @param _targetBaseAssetAllocation Target allocation of the base asset\n * @return ISetToken The address of the proposed nextSet\n */\n function determineNewAllocation(\n uint256 _targetBaseAssetAllocation\n )\n external\n returns (ISetToken);\n\n /*\n * Calculate value of passed collateral set.\n *\n * @param _collateralSet Instance of current set collateralizing RebalancingSetToken\n * @return uint256 USD value of passed Set\n */\n function calculateCollateralSetValue(\n ISetToken _collateralSet\n )\n external\n view\n returns(uint256);\n}\n"
},
{
"path": "contracts/mocks/supplementary/ISocialTradingManager.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ILiquidator } from \"../../core/interfaces/ILiquidator.sol\";\nimport { IRebalancingSetTokenV2 } from \"../../core/interfaces/IRebalancingSetTokenV2.sol\";\n\nimport { ISocialAllocator } from \"./ISocialAllocator.sol\";\nimport { SocialTradingLibrary } from \"./SocialTradingLibrary.sol\";\n\n/**\n * @title ISocialTradingManager\n * @author Set Protocol\n *\n * Interface for interacting with SocialTradingManager contracts\n */\ninterface ISocialTradingManager {\n\n /*\n * Get trading pool info.\n *\n * @param _tradingPool The address of the trading pool being queried\n *\n * @return PoolInfo struct of trading pool\n */\n function pools(address _tradingPool) external view returns (SocialTradingLibrary.PoolInfo memory);\n\n /*\n * Create a trading pool. Create or select new collateral and create RebalancingSetToken contract to\n * administer pool. Save relevant data to pool's entry in pools state variable under the Rebalancing\n * Set Token address.\n *\n * @param _tradingPairAllocator The address of the allocator the trader wishes to use\n * @param _startingBaseAssetAllocation Starting base asset allocation in a scaled decimal value\n * (e.g. 100% = 1e18, 1% = 1e16)\n * @param _startingUSDValue Starting value of one share of the trading pool to 18 decimals of precision\n * @param _name The name of the new RebalancingSetTokenV2\n * @param _symbol The symbol of the new RebalancingSetTokenV2\n * @param _rebalancingSetCallData Byte string containing additional call parameters to pass to factory\n */\n function createTradingPool(\n ISocialAllocator _tradingPairAllocator,\n uint256 _startingBaseAssetAllocation,\n uint256 _startingUSDValue,\n bytes32 _name,\n bytes32 _symbol,\n bytes calldata _rebalancingSetCallData\n )\n external;\n\n /*\n * Update trading pool allocation. Issue new collateral Set and initiate rebalance on RebalancingSetTokenV2.\n *\n * @param _tradingPool The address of the trading pool being updated\n * @param _newAllocation New base asset allocation in a scaled decimal value\n * (e.g. 100% = 1e18, 1% = 1e16)\n * @param _liquidatorData Extra parameters passed to the liquidator\n */\n function updateAllocation(\n IRebalancingSetTokenV2 _tradingPool,\n uint256 _newAllocation,\n bytes calldata _liquidatorData\n )\n external;\n\n /*\n * Update trader allowed to manage trading pool.\n *\n * @param _tradingPool The address of the trading pool being updated\n * @param _newTrader Address of new traders\n */\n function setTrader(\n IRebalancingSetTokenV2 _tradingPool,\n address _newTrader\n )\n external;\n\n /*\n * Update liquidator used by tradingPool.\n *\n * @param _tradingPool The address of the trading pool being updated\n * @param _newLiquidator Address of new Liquidator\n */\n function setLiquidator(\n IRebalancingSetTokenV2 _tradingPool,\n ILiquidator _newLiquidator\n )\n external;\n\n /*\n * Update fee recipient of tradingPool.\n *\n * @param _tradingPool The address of the trading pool being updated\n * @param _newFeeRecipient Address of new fee recipient\n */\n function setFeeRecipient(\n IRebalancingSetTokenV2 _tradingPool,\n address _newFeeRecipient\n )\n external;\n}\n"
},
{
"path": "contracts/mocks/supplementary/SocialTradingLibrary.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { ISocialAllocator } from \"./ISocialAllocator.sol\";\n\n\n/**\n * @title SocialTradingLibrary\n * @author Set Protocol\n *\n * Library for use in SocialTrading system.\n */\nlibrary SocialTradingLibrary {\n\n /* ============ Structs ============ */\n struct PoolInfo {\n address trader; // Address allowed to make admin and allocation decisions\n ISocialAllocator allocator; // Allocator used to make collateral Sets, defines asset pair being used\n uint256 currentAllocation; // Current base asset allocation of tradingPool\n uint256 newEntryFee; // New fee percentage to change to after time lock passes, defaults to 0\n uint256 feeUpdateTimestamp; // Timestamp when fee update process can be finalized, defaults to maxUint256\n }\n}\n"
},
{
"path": "contracts/mocks/supplementary/SocialTradingManagerMock.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { SocialTradingLibrary } from \"./SocialTradingLibrary.sol\";\nimport { ISocialAllocator } from \"./ISocialAllocator.sol\";\n\nimport { IRebalancingSetTokenV2 } from \"../../core/interfaces/IRebalancingSetTokenV2.sol\";\nimport { ISetToken } from \"../../core/interfaces/ISetToken.sol\";\n\n/**\n * @title SocialTradingManagerMock\n * @author Set Protocol\n *\n * Mock for SocialTradingManager to test viewer.\n */\ncontract SocialTradingManagerMock {\n mapping(address => SocialTradingLibrary.PoolInfo) public pools;\n\n function updateRecord(\n address _tradingPool,\n address _trader,\n ISocialAllocator _allocator,\n uint256 _currentAllocation\n )\n external\n {\n pools[_tradingPool].trader = _trader;\n pools[_tradingPool].allocator = _allocator;\n pools[_tradingPool].currentAllocation = _currentAllocation;\n }\n\n function rebalance(\n IRebalancingSetTokenV2 _tradingPool,\n ISetToken _nextSet,\n uint256 _newAllocation,\n bytes calldata _liquidatorData\n )\n external\n {\n _tradingPool.startRebalance(address(_nextSet), _liquidatorData);\n\n pools[address(_tradingPool)].currentAllocation = _newAllocation;\n }\n\n function updateFee(\n address _tradingPool,\n uint256 _newFee\n )\n external\n {\n pools[_tradingPool].newEntryFee = _newFee;\n pools[_tradingPool].feeUpdateTimestamp = block.timestamp;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/BadCTokenMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\n\ncontract BadCTokenMock is ERC20 {\n uint256 constant public decimals = 8;\n string public name;\n string public symbol;\n address public underlyingToken;\n\n constructor(\n address initialAccount,\n uint256 initialBalance,\n string memory _name,\n string memory _symbol\n )\n public\n {\n _mint(initialAccount, initialBalance);\n name = _name;\n symbol = _symbol;\n }\n\n /**\n * @dev Mint function that returns a nonzero number which is an error on Compound\n * @param _value The amount of cTokens to be minted.\n */\n function mint(uint _value) public returns (uint) {\n return 1;\n }\n\n /**\n * @dev Redeem function that returns a nonzero number which is an error on Compound\n * @param _value The amount of cTokens to be redeemed.\n */\n function redeem(uint _value) public returns (uint) {\n return 1;\n }\n\n function exchangeRateCurrent()\n public\n returns (uint)\n {\n return 200000000000000;\n }\n\n function exchangeRateStored()\n public\n view\n returns (uint)\n {\n return 200000000000000;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/BadTokenMock.sol",
"content": "pragma solidity 0.5.7;\n\n\nimport \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\n\n\n// mock class using BasicToken\ncontract BadTokenMock is ERC20 {\n uint256 constant public decimals = 18;\n string public name;\n string public symbol;\n\n constructor(\n address initialAccount,\n uint256 initialBalance,\n string memory _name,\n string memory _symbol)\n public\n {\n _mint(initialAccount, initialBalance);\n name = _name;\n symbol = _symbol;\n }\n\n /**\n * @dev Transfer token for a specified address\n * @param _to The address to transfer to.\n * @param _value The amount to be transferred.\n */\n function transfer(address _to, uint256 _value) public returns (bool) {\n require(_to != address(0));\n require(_value <= balanceOf(msg.sender));\n\n // BAD TOKEN which does not update balances properly\n\n emit Transfer(msg.sender, _to, _value);\n return true;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/InvalidReturnTokenMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\n// mock class using BasicToken\ncontract InvalidReturnTokenMock {\n\n using SafeMath for uint;\n mapping(address => uint256) balances;\n mapping (address => mapping (address => uint256)) internal allowed;\n\n uint256 public decimals;\n string public name;\n string public symbol;\n uint256 public totalSupply;\n\n event Transfer(\n address indexed from,\n address indexed to,\n uint256 value\n );\n\n event Approval(\n address indexed owner,\n address indexed spender,\n uint256 value\n );\n\n constructor(\n address initialAccount,\n uint256 initialBalance,\n string memory _name,\n string memory _symbol,\n uint256 _decimals)\n public\n {\n balances[initialAccount] = initialBalance;\n totalSupply = initialBalance;\n name = _name;\n symbol = _symbol;\n decimals = _decimals;\n }\n\n /**\n * @dev Transfer token for a specified address\n * @param _to The address to transfer to.\n * @param _value The amount to be transferred.\n */\n function transfer(\n address _to,\n uint256 _value\n )\n external\n returns (uint256)\n {\n require(_to != address(0));\n require(_value <= balances[msg.sender]);\n\n balances[msg.sender] = balances[msg.sender].sub(_value);\n balances[_to] = balances[_to].add(_value);\n emit Transfer(msg.sender, _to, _value);\n return 4;\n }\n\n /**\n * @dev Gets the balance of the specified address.\n * @param _owner The address to query the the balance of.\n * @return An uint256 representing the amount owned by the passed address.\n */\n function balanceOf(address _owner) external view returns (uint256) {\n return balances[_owner];\n }\n\n /**\n * @dev Transfer tokens from one address to another\n * @param _from address The address which you want to send tokens from\n * @param _to address The address which you want to transfer to\n * @param _value uint256 the amount of tokens to be transferred\n */\n function transferFrom(\n address _from,\n address _to,\n uint256 _value\n )\n external\n returns (uint256)\n {\n require(_to != address(0));\n require(_value <= balances[_from]);\n require(_value <= allowed[_from][msg.sender]);\n\n balances[_from] = balances[_from].sub(_value);\n balances[_to] = balances[_to].add(_value);\n allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);\n emit Transfer(_from, _to, _value);\n return 4;\n }\n\n /**\n * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.\n * Beware that changing an allowance with this method brings the risk that someone may use both the old\n * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this\n * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n * @param _spender The address which will spend the funds.\n * @param _value The amount of tokens to be spent.\n */\n function approve(\n address _spender,\n uint256 _value\n )\n external\n returns (uint256)\n {\n allowed[msg.sender][_spender] = _value;\n emit Approval(msg.sender, _spender, _value);\n return 4;\n }\n\n /**\n * @dev Function to check the amount of tokens that an owner allowed to a spender.\n * @param _owner address The address which owns the funds.\n * @param _spender address The address which will spend the funds.\n * @return A uint256 specifying the amount of tokens still available for the spender.\n */\n function allowance(\n address _owner,\n address _spender\n )\n external\n view\n returns (uint256)\n {\n return allowed[_owner][_spender];\n }\n\n /**\n * @dev Increase the amount of tokens that an owner allowed to a spender.\n * approve should be called when allowed[_spender] == 0. To increment\n * allowed value is better to use this function to avoid 2 calls (and wait until\n * the first transaction is mined)\n * From MonolithDAO Token.sol\n * @param _spender The address which will spend the funds.\n * @param _addedValue The amount of tokens to increase the allowance by.\n */\n function increaseApproval(\n address _spender,\n uint256 _addedValue\n )\n external\n returns (uint256)\n {\n allowed[msg.sender][_spender] = (\n allowed[msg.sender][_spender].add(_addedValue));\n emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);\n return 4;\n }\n\n /**\n * @dev Decrease the amount of tokens that an owner allowed to a spender.\n * approve should be called when allowed[_spender] == 0. To decrement\n * allowed value is better to use this function to avoid 2 calls (and wait until\n * the first transaction is mined)\n * From MonolithDAO Token.sol\n * @param _spender The address which will spend the funds.\n * @param _subtractedValue The amount of tokens to decrease the allowance by.\n */\n function decreaseApproval(\n address _spender,\n uint256 _subtractedValue\n )\n external\n returns (uint256)\n {\n uint256 oldValue = allowed[msg.sender][_spender];\n if (_subtractedValue > oldValue) {\n allowed[msg.sender][_spender] = 0;\n } else {\n allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);\n }\n emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);\n return 4;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/LiquidatorMock.sol",
"content": "/*\n Copyright 2019 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\npragma experimental \"ABIEncoderV2\";\n\nimport { Math } from \"openzeppelin-solidity/contracts/math/Math.sol\";\nimport { SafeMath } from \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\nimport { AddressArrayUtils } from \"set-protocol-contract-utils/contracts/lib/AddressArrayUtils.sol\";\n\nimport { ISetToken } from \"../../core/interfaces/ISetToken.sol\";\nimport { ILiquidator } from \"../../core/interfaces/ILiquidator.sol\";\nimport { Rebalance } from \"../../core/lib/Rebalance.sol\";\nimport { RebalancingLibrary } from \"../../core/lib/RebalancingLibrary.sol\";\n\n/**\n * @title LiquidatorMock\n * @author Set Protocol\n *\n */\ncontract LiquidatorMock is\n ILiquidator\n{\n using SafeMath for uint256;\n using AddressArrayUtils for address[];\n\n // Legacy Data\n RebalancingLibrary.AuctionPriceParameters private auctionPriceParams;\n\n uint256 constant public priceDivisor = 1000;\n uint256 public priceNumerator = 1000;\n\n ISetToken public currentSet;\n ISetToken public nextSet;\n\n uint256 private _minimumBid;\n\n uint256 public startRebalanceTime;\n uint256 private _startingCurrentSetAmount;\n uint256 private _remainingCurrentSets;\n\n address[] private _combinedTokenArray;\n uint256[] private _combinedCurrentUnits;\n uint256[] private _combinedNextSetUnits;\n\n uint256 public placeBidQuantity;\n\n bool public hasSettled;\n bool public hasFailed;\n bool public endFailedRebalanceHasBeenCalled;\n\n bytes public liquidatorData;\n\n /* ============ External Functions ============ */\n\n function getBidPrice(\n address _set,\n uint256 _quantity\n )\n external\n view\n returns (Rebalance.TokenFlow memory)\n {\n uint256[] memory inflowUnits = getInflowTokenTransferValues(nextSet, _quantity, _combinedNextSetUnits);\n uint256[] memory outflowUnits = getTransferValues(currentSet, _quantity, _combinedCurrentUnits);\n\n return Rebalance.composeTokenFlow(\n _combinedTokenArray,\n inflowUnits,\n outflowUnits\n ); \n }\n\n function placeBid(\n uint256 _quantity\n )\n external\n returns (Rebalance.TokenFlow memory)\n {\n placeBidQuantity = _quantity;\n\n // Subtract remaining Sets\n _remainingCurrentSets = _remainingCurrentSets.sub(_quantity);\n\n // Inflow = quantity (currentSet) * units / naturalUnit\n uint256[] memory inflowUnits = getInflowTokenTransferValues(nextSet, _quantity, _combinedNextSetUnits);\n uint256[] memory outflowUnits = getTransferValues(currentSet, _quantity, _combinedCurrentUnits);\n\n return Rebalance.composeTokenFlow(\n _combinedTokenArray,\n inflowUnits,\n outflowUnits\n );\n }\n\n function startRebalance(\n ISetToken _currentSet,\n ISetToken _nextSet,\n uint256 startingCurrentSetAmount_,\n bytes calldata _liquidatorData\n )\n external\n {\n liquidatorData = _liquidatorData;\n\n currentSet = _currentSet;\n nextSet = _nextSet;\n\n startRebalanceTime = block.timestamp;\n _startingCurrentSetAmount = startingCurrentSetAmount_;\n _remainingCurrentSets = _startingCurrentSetAmount;\n\n _minimumBid = calculateMinimumBid(_currentSet, _nextSet);\n\n // Set the combined token array\n address[] memory currentSetComponents = _currentSet.getComponents();\n address[] memory nextSetComponents = _nextSet.getComponents();\n _combinedTokenArray = currentSetComponents.union(nextSetComponents);\n\n _combinedCurrentUnits = getCombinedUnitsArray(_currentSet, _combinedTokenArray);\n _combinedNextSetUnits = getCombinedUnitsArray(_nextSet, _combinedTokenArray);\n }\n\n function setAuctionPriceParameters(\n uint256 _auctionStartTime,\n uint256 _auctionTimeToPivot,\n uint256 _auctionStartPrice,\n uint256 _auctionPivotPrice\n ) external {\n auctionPriceParams.auctionStartTime = _auctionStartTime;\n auctionPriceParams.auctionTimeToPivot = _auctionTimeToPivot;\n auctionPriceParams.auctionStartPrice = _auctionStartPrice;\n auctionPriceParams.auctionPivotPrice = _auctionPivotPrice;\n }\n\n function settleRebalance() external {\n hasSettled = true;\n }\n\n function hasRebalanceFailed(address _set) external view returns (bool) {\n return hasFailed;\n }\n\n function endFailedRebalance() external {\n endFailedRebalanceHasBeenCalled = true;\n }\n\n /* ============ Setter Functions ============ */\n\n function setHasFailed(bool _hasFailed) external {\n hasFailed = _hasFailed;\n }\n\n function setPriceNumerator(uint256 _priceNumerator) external {\n priceNumerator = _priceNumerator;\n }\n\n /* ============ Getter Functions ============ */\n\n function auctionPriceParameters(address _set)\n external\n view\n returns (RebalancingLibrary.AuctionPriceParameters memory)\n {\n return auctionPriceParams;\n }\n\n function getAuctionPriceParameters(address _set)\n external\n view\n returns (uint256[] memory)\n {\n uint256[] memory auctionParams = new uint256[](4);\n auctionParams[0] = auctionPriceParams.auctionStartTime;\n auctionParams[1] = auctionPriceParams.auctionTimeToPivot;\n auctionParams[2] = auctionPriceParams.auctionStartPrice;\n auctionParams[3] = auctionPriceParams.auctionPivotPrice;\n return auctionParams;\n }\n\n function minimumBid(address _set) external view returns (uint256) {\n return _minimumBid;\n }\n\n function remainingCurrentSets(address _set) external view returns (uint256) {\n return _remainingCurrentSets;\n }\n\n function startingCurrentSets(address _set) external view returns (uint256) {\n return _startingCurrentSetAmount;\n }\n\n function getCombinedTokenArray(address _set) external view returns (address[] memory) {\n return _combinedTokenArray;\n }\n \n function getCombinedCurrentSetUnits(address _set) external view returns (uint256[] memory) {\n return _combinedCurrentUnits;\n }\n\n function getCombinedNextSetUnits(address _set) external view returns (uint256[] memory) {\n return _combinedNextSetUnits;\n }\n\n /* ============ Private Functions ============ */\n\n function getCombinedUnitsArray(\n ISetToken _setToken,\n address[] memory combinedTokenArray_\n )\n private\n view\n returns (uint256[] memory)\n {\n uint256[] memory combinedUnits = new uint256[](combinedTokenArray_.length);\n\n for (uint256 i = 0; i < combinedTokenArray_.length; i++) {\n address currentComponent = combinedTokenArray_[i];\n\n (uint256 indexCurrent, bool isComponent) = _setToken.getComponents().indexOf(currentComponent);\n\n combinedUnits[i] = isComponent ? _setToken.getUnits()[indexCurrent] : 0;\n }\n\n return combinedUnits;\n }\n\n function getInflowTokenTransferValues(\n ISetToken _setToken,\n uint256 _quantity,\n uint256[] memory _combinedUnits \n )\n private\n view\n returns(uint256[] memory)\n {\n uint256[] memory unpricedInflowTokens = getTransferValues(\n _setToken,\n _quantity,\n _combinedUnits\n );\n\n for (uint256 i = 0; i < unpricedInflowTokens.length; i++) {\n unpricedInflowTokens[i] = unpricedInflowTokens[i].mul(priceNumerator).div(priceDivisor);\n }\n\n return unpricedInflowTokens;\n }\n\n function getTransferValues(\n ISetToken _setToken,\n uint256 _quantity,\n uint256[] memory _combinedUnits\n ) \n private\n view\n returns (uint256[] memory)\n {\n uint256 naturalUnit = _setToken.naturalUnit();\n\n uint256[] memory transferValues = new uint256[](_combinedUnits.length);\n\n for (uint256 i = 0; i < _combinedUnits.length; i++) {\n transferValues[i] = _quantity.mul(_combinedUnits[i]).div(naturalUnit);\n }\n\n return transferValues;\n }\n\n function calculateMinimumBid(\n ISetToken _currentSet,\n ISetToken _nextSet\n )\n private\n view\n returns (uint256)\n {\n uint256 currentSetNaturalUnit = _currentSet.naturalUnit();\n uint256 nextSetNaturalUnit = _nextSet.naturalUnit();\n\n return Math.max(\n currentSetNaturalUnit.mul(priceDivisor),\n nextSetNaturalUnit.mul(priceDivisor)\n );\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/NoDecimalTokenMock.sol",
"content": "pragma solidity 0.5.7;\n\n\nimport \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\n\n\ncontract NoDecimalTokenMock is ERC20 {\n string public name;\n string public symbol;\n\n constructor(\n address initialAccount,\n uint256 initialBalance,\n string memory _name,\n string memory _symbol)\n public\n {\n _mint(initialAccount, initialBalance);\n name = _name;\n symbol = _symbol;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/NoXferReturnTokenMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\n// mock class using BasicToken\ncontract NoXferReturnTokenMock {\n\n using SafeMath for uint256;\n\n mapping(address => uint256) balances;\n mapping (address => mapping (address => uint256)) internal allowed;\n\n uint256 public decimals;\n string public name;\n string public symbol;\n uint256 public totalSupply;\n\n constructor(\n address initialAccount,\n uint256 initialBalance,\n string memory _name,\n string memory _symbol,\n uint256 _decimals)\n public\n {\n balances[initialAccount] = initialBalance;\n totalSupply = initialBalance;\n name = _name;\n symbol = _symbol;\n decimals = _decimals;\n }\n\n /**\n * @dev Transfer token for a specified address\n * @param _to The address to transfer to.\n * @param _value The amount to be transferred.\n */\n function transfer(address _to, uint256 _value) external {\n require(_to != address(0));\n require(_value <= balances[msg.sender]);\n\n balances[msg.sender] = balances[msg.sender].sub(_value);\n balances[_to] = balances[_to].add(_value);\n }\n\n /**\n * @dev Gets the balance of the specified address.\n * @param _owner The address to query the the balance of.\n * @return An uint256 representing the amount owned by the passed address.\n */\n function balanceOf(address _owner) external view returns (uint256) {\n return balances[_owner];\n }\n\n /**\n * @dev Transfer tokens from one address to another\n * @param _from address The address which you want to send tokens from\n * @param _to address The address which you want to transfer to\n * @param _value uint256 the amount of tokens to be transferred\n */\n function transferFrom(\n address _from,\n address _to,\n uint256 _value\n )\n external\n {\n require(_to != address(0));\n require(_value <= balances[_from]);\n require(_value <= allowed[_from][msg.sender]);\n\n balances[_from] = balances[_from].sub(_value);\n balances[_to] = balances[_to].add(_value);\n allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);\n }\n\n /**\n * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.\n * Beware that changing an allowance with this method brings the risk that someone may use both the old\n * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this\n * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n * @param _spender The address which will spend the funds.\n * @param _value The amount of tokens to be spent.\n */\n function approve(address _spender, uint256 _value) external {\n allowed[msg.sender][_spender] = _value;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/PlaceBidMock.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\n\npragma solidity 0.5.7;\n\nimport { IRebalancingSetToken } from \"../../core/interfaces/IRebalancingSetToken.sol\";\n\n/**\n * @title PlaceBidMock\n * @author Set Protocol\n *\n * The PlaceBidMock\n */\ncontract PlaceBidMock\n{\n address[] private storedCombinedTokenArray;\n uint256[] private inflowUnits;\n uint256[] private outflowUnits;\n\n /* ============ External Functions ============ */\n\n function mockPlaceBid(\n IRebalancingSetToken _rebalancingSetToken,\n uint256 _quantity\n )\n external\n {\n (\n address[] memory combinedTokenArray,\n uint256[] memory inflowUnitArray,\n uint256[] memory outflowUnitArray\n ) = _rebalancingSetToken.placeBid(_quantity);\n\n storedCombinedTokenArray = combinedTokenArray;\n inflowUnits = inflowUnitArray;\n outflowUnits = outflowUnitArray;\n }\n\n function getCombinedTokenArray()\n external\n view\n returns (address[] memory)\n {\n return storedCombinedTokenArray;\n }\n\n function getInflowUnits()\n external\n view\n returns (uint256[] memory)\n {\n return inflowUnits;\n }\n\n function getOutflowUnits()\n external\n view\n returns (uint256[] memory)\n {\n return outflowUnits;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/RebalanceStateSetTokenMock.sol",
"content": "pragma solidity 0.5.7;\n\n\nimport \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\n\n// Mock Rebalancing Set in Rebalance State\ncontract RebalanceStateSetTokenMock is ERC20 {\n uint256 public decimals;\n string public name;\n string public symbol;\n address[] public combinedTokenArray;\n uint256[] public inflowArray;\n uint256[] public outflowArray;\n\n constructor(\n string memory _name,\n string memory _symbol,\n uint256 _decimals,\n address[] memory _combinedTokenArray,\n uint256[] memory _inflowArray,\n uint256[] memory _outflowArray\n )\n public\n {\n name = _name;\n symbol = _symbol;\n decimals = _decimals;\n combinedTokenArray = _combinedTokenArray;\n inflowArray = _inflowArray;\n outflowArray = _outflowArray;\n }\n function getCombinedTokenArray()\n external\n view\n returns (address[] memory)\n {\n return combinedTokenArray;\n }\n function getBidPrice(uint256 _quantity)\n external\n view\n returns (uint256[] memory, uint256[] memory)\n {\n return (inflowArray, outflowArray);\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/StandardTokenMock.sol",
"content": "pragma solidity 0.5.7;\n\n\nimport \"openzeppelin-solidity/contracts/token/ERC20/ERC20.sol\";\n\n\n// mock class using BasicToken\ncontract StandardTokenMock is ERC20 {\n uint256 public decimals;\n string public name;\n string public symbol;\n\n constructor(\n address initialAccount,\n uint256 initialBalance,\n string memory _name,\n string memory _symbol,\n uint256 _decimals)\n public\n {\n _mint(initialAccount, initialBalance);\n name = _name;\n symbol = _symbol;\n decimals = _decimals;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/StandardTokenWithFeeMock.sol",
"content": "/*\n Copyright 2018 Set Labs Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/\npragma solidity 0.5.7;\n\n\nimport \"openzeppelin-solidity/contracts/math/SafeMath.sol\";\n\n\n// mock class using BasicToken\ncontract StandardTokenWithFeeMock {\n using SafeMath for uint256;\n\n event Transfer(\n address indexed from,\n address indexed to,\n uint256 value\n );\n\n event Approval(\n address indexed owner,\n address indexed spender,\n uint256 value\n );\n\n uint256 constant public decimals = 18;\n string public name;\n string public symbol;\n uint256 public fee;\n\n mapping (address => uint256) public _balances;\n\n mapping (address => mapping (address => uint256)) public _allowed;\n\n uint256 public _totalSupply;\n\n constructor(\n address initialAccount,\n uint256 initialBalance,\n string memory _name,\n string memory _symbol,\n uint256 _fee)\n public\n {\n _balances[initialAccount] = initialBalance;\n _totalSupply = initialBalance;\n name = _name;\n symbol = _symbol;\n fee = _fee;\n }\n\n /**\n * @dev Transfer tokens from one address to another with a fee component\n * @param _from address The address which you want to send tokens from\n * @param _to address The address which you want to transfer to\n * @param _value uint256 the amount of tokens to be transferred\n */\n function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {\n require(_to != address(0), \"to nonnull\");\n require(_value <= _balances[_from], \"less than from\");\n require(_value <= _allowed[_from][msg.sender], \"value less than allowed\");\n\n uint256 netValueMinusFee = _value.sub(fee);\n\n _balances[_from] = _balances[_from].sub(_value);\n _balances[_to] = _balances[_to].add(netValueMinusFee);\n _allowed[_from][msg.sender] = _allowed[_from][msg.sender].sub(_value);\n emit Transfer(_from, _to, _value);\n return true;\n }\n\n /**\n * @dev transfer token for a specified address with a fee component applied to the send\n * @param _to The address to transfer to.\n * @param _value The amount to be transferred.\n */\n function transfer(address _to, uint256 _value) external returns (bool) {\n require(_to != address(0));\n require(_value <= _balances[msg.sender]);\n\n uint256 netValuePlusFee = _value.add(fee);\n\n // SafeMath.sub will throw if there is not enough balance.\n _balances[msg.sender] = _balances[msg.sender].sub(netValuePlusFee);\n _balances[_to] = _balances[_to].add(_value);\n emit Transfer(msg.sender, _to, _value);\n return true;\n }\n\n function setFee(uint256 _fee) external returns (bool) {\n fee = _fee;\n return true;\n }\n\n function totalSupply() external view returns (uint256) {\n return _totalSupply;\n }\n\n function balanceOf(address owner) external view returns (uint256) {\n return _balances[owner];\n }\n\n function allowance(\n address owner,\n address spender\n )\n external\n view\n returns (uint256)\n {\n return _allowed[owner][spender];\n }\n\n function approve(address spender, uint256 value) external returns (bool) {\n require(spender != address(0));\n\n _allowed[msg.sender][spender] = value;\n emit Approval(msg.sender, spender, value);\n return true;\n }\n\n function increaseAllowance(\n address spender,\n uint256 addedValue\n )\n external\n returns (bool)\n {\n require(spender != address(0));\n\n _allowed[msg.sender][spender] = (\n _allowed[msg.sender][spender].add(addedValue));\n emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);\n return true;\n }\n\n function decreaseAllowance(\n address spender,\n uint256 subtractedValue\n )\n external\n returns (bool)\n {\n require(spender != address(0));\n\n _allowed[msg.sender][spender] = (\n _allowed[msg.sender][spender].sub(subtractedValue));\n emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);\n return true;\n }\n}\n"
},
{
"path": "contracts/mocks/tokens/WethMock.sol",
"content": "pragma solidity 0.5.7;\n\nimport \"canonical-weth/contracts/WETH9.sol\";\n\ncontract WethMock is WETH9 {\n\tconstructor(\n\t address initialAccount,\n\t uint256 initialBalance\n )\n\t public\n\t{\n\t balanceOf[initialAccount] = initialBalance;\n\t}\n\n function changeAllowanceProxy(address _owner, address _spender, uint256 _value) public {\n require(_spender != address(0));\n require(_owner != address(0));\n\n allowance[_owner][_spender] = _value;\n emit Approval(_owner, _spender, _value);\n }\n}\n"
},
{
"path": "migrations/1_initial_migration.js",
"content": "var Migrations = artifacts.require(\"./Migrations.sol\");\n\nmodule.exports = function(deployer, network, accounts) {};"
},
{
"path": "outputs.tmp",
"content": ""
},
{
"path": "package.json",
"content": "{\n \"name\": \"set-protocol-contracts\",\n \"version\": \"1.4.18-beta\",\n \"description\": \"Smart contracts for {Set} Protocol\",\n \"main\": \"dist/artifacts/index.js\",\n \"typings\": \"dist/typings/artifacts/index.d.ts\",\n \"files\": [\n \"dist\",\n \"contracts\",\n \"migrations\",\n \"scripts\",\n \"truffle.js\",\n \"tsconfig.dist.json\"\n ],\n \"directories\": {\n \"test\": \"test\"\n },\n \"scripts\": {\n \"chain\": \"yarn clean-chain && ganache-cli --db blockchain --networkId 50 --accounts 20 -l 20000000 -e 10000000000 -m 'concert load couple harbor equip island argue ramp clarify fence smart topic'\",\n \"clean\": \"rm -rf build; rm -rf transpiled; rm -rf types/generated\",\n \"clean-chain\": \"rm -rf blockchain && cp -r snapshots/0x-Kyber-Compound blockchain\",\n \"buidler-new\": \"yarn buidler clean && yarn buidler-test\",\n \"buidler-test\": \"yarn buidler-setup && buidler test `find test/contracts -name '*.spec.ts'`\",\n \"buidler-setup\": \"buidler compile && bash scripts/buidler_deploy_dev.sh && yarn transformJson && yarn generate-typings\",\n \"compile\": \"./node_modules/.bin/truffle compile --all\",\n \"coverage\": \"yarn coverage-setup && ./node_modules/.bin/solidity-coverage && yarn coverage-cleanup\",\n \"coverage-cleanup\": \"find artifacts/ts -name \\\\*.js* -type f -delete && find test -name \\\\*.js* -type f -delete && find types -name \\\\*.js* -type f -delete && find utils -name \\\\*.js* -type f -delete\",\n \"coverage-continuous\": \"./node_modules/.bin/solidity-coverage\",\n \"coverage-setup\": \"yarn transpile && cp -r transpiled/artifacts/ts/* artifacts/ts/. && cp -r transpiled/test/contracts/* test/. && cp -r transpiled/types/* types/. && cp -r transpiled/utils/* utils/.\",\n \"delete-dev-addresses\": \"jq 'del(.development)' ./deployments/outputs.json > outputs.tmp && mv outputs.tmp ./deployments/outputs.json && bash scripts/generate_outputs.sh && git add .\",\n \"deploy-development\": \"bash scripts/deploy_development.sh && yarn transformJson\",\n \"dist\": \"yarn setup && bash scripts/prepare_dist.sh\",\n \"generate-typings\": \"set-abi-gen --abis './build/contracts/*.json' --out './types/generated' --template './types/contract_templates/contract.mustache' --partials './types/contract_templates/partials/*.mustache'\",\n \"lint\": \"yarn run lint-sol && yarn run lint-ts\",\n \"lint-sol\": \"solium -d contracts/\",\n \"lint-ts\": \"tslint -c tslint.json -p tsconfig.json --fix test/**/*.ts utils/**/*.ts\",\n \"precommit\": \"lint-staged\",\n \"prepare-test\": \"yarn setup && yarn transpile\",\n \"profile-gas\": \"yarn prepare-test && truffle test `find transpiled/test/profile -name '*.spec.js'`\",\n \"postinstall\": \"bash scripts/fix-web3-eth-abi.sh\",\n \"setup\": \"yarn clean && yarn deploy-development && yarn generate-typings\",\n \"test\": \"yarn prepare-test && yarn truffle-test-contracts\",\n \"test-nocompile\": \"yarn transpile && yarn truffle-test-contracts\",\n \"test-continuous\": \"yarn deploy-development && truffle test\",\n \"transpile\": \"tsc\",\n \"transpile-dist\": \"tsc --p tsconfig.dist.json\",\n \"transformJson\": \"node scripts/transform_contract_json.js\",\n \"truffle-test-contracts\": \"truffle test `find transpiled/test/contracts -name '*.spec.js'`\",\n \"prepublishOnly\": \"yarn dist\",\n \"flatten\": \"truffle-flattener contracts/core/[xxx]/[xxx].sol\",\n \"minify-artifacts\": \"yarn run minify-all dist/artifacts/ts/\"\n },\n \"repository\": \"git@github.com:SetProtocol/set-protocol-contracts.git\",\n \"author\": \"Felix Feng