Sponsored
MoonPay
Buy, sell and swap Ethereum with MoonPay.Buy Now!
20M+ users trust MoonPay worldwide. Checkout with your preferred payment method.
MetaMask
Manage your web3 everything with MetaMask Portfolio. Try Now!
Ready to onboard to Ethereum? With MetaMask Portfolio, you're in control.
eToro
One-stop crypto shop: trusted, simple & safe.
Don’t invest unless you’re prepared to lose all the money you invest.
Sponsored
Сoins.game
100 free spins for registration. Spin now!
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
Stake
200% Bonus, 100K Daily Giveaways, Instant Withdrawals Play Now!
Slots, Roulette, Poker & more - Proud sponsors of UFC, Everton & StakeF1 team!
Sponsored
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
CryptoSlots
Play & Get 25 Free Spins at CryptoSlots Play Now
Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!
CryptoWins
200% More Funds to Play on Us up to 4 BTC! Claim Now!
100s of games, generous bonuses, 20+ years of trusted gaming. Join CryptoWins & start winning today!
Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
| 0x60806040 | 9282335 | 1774 days ago | IN | 0 ETH | 0.00218277 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
FixedFeeCalculator
Compiler Version
v0.5.7+commit.6da8b019
Contract Source Code (Solidity)
/**
*Submitted for verification at Etherscan.io on 2020-01-15
*/
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
pragma solidity ^0.5.2;
/**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: contracts/lib/CommonMath.sol
/*
Copyright 2018 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
library CommonMath {
using SafeMath for uint256;
uint256 public constant SCALE_FACTOR = 10 ** 18;
uint256 public constant MAX_UINT_256 = 2 ** 256 - 1;
/**
* Returns scale factor equal to 10 ** 18
*
* @return 10 ** 18
*/
function scaleFactor()
internal
pure
returns (uint256)
{
return SCALE_FACTOR;
}
/**
* Calculates and returns the maximum value for a uint256
*
* @return The maximum value for uint256
*/
function maxUInt256()
internal
pure
returns (uint256)
{
return MAX_UINT_256;
}
/**
* Increases a value by the scale factor to allow for additional precision
* during mathematical operations
*/
function scale(
uint256 a
)
internal
pure
returns (uint256)
{
return a.mul(SCALE_FACTOR);
}
/**
* Divides a value by the scale factor to allow for additional precision
* during mathematical operations
*/
function deScale(
uint256 a
)
internal
pure
returns (uint256)
{
return a.div(SCALE_FACTOR);
}
/**
* @dev Performs the power on a specified value, reverts on overflow.
*/
function safePower(
uint256 a,
uint256 pow
)
internal
pure
returns (uint256)
{
require(a > 0);
uint256 result = 1;
for (uint256 i = 0; i < pow; i++){
uint256 previousResult = result;
// Using safemath multiplication prevents overflows
result = previousResult.mul(a);
}
return result;
}
/**
* @dev Performs division where if there is a modulo, the value is rounded up
*/
function divCeil(uint256 a, uint256 b)
internal
pure
returns(uint256)
{
return a.mod(b) > 0 ? a.div(b).add(1) : a.div(b);
}
/**
* Checks for rounding errors and returns value of potential partial amounts of a principal
*
* @param _principal Number fractional amount is derived from
* @param _numerator Numerator of fraction
* @param _denominator Denominator of fraction
* @return uint256 Fractional amount of principal calculated
*/
function getPartialAmount(
uint256 _principal,
uint256 _numerator,
uint256 _denominator
)
internal
pure
returns (uint256)
{
// Get remainder of partial amount (if 0 not a partial amount)
uint256 remainder = mulmod(_principal, _numerator, _denominator);
// Return if not a partial amount
if (remainder == 0) {
return _principal.mul(_numerator).div(_denominator);
}
// Calculate error percentage
uint256 errPercentageTimes1000000 = remainder.mul(1000000).div(_numerator.mul(_principal));
// Require error percentage is less than 0.1%.
require(
errPercentageTimes1000000 < 1000,
"CommonMath.getPartialAmount: Rounding error exceeds bounds"
);
return _principal.mul(_numerator).div(_denominator);
}
/*
* Gets the rounded up log10 of passed value
*
* @param _value Value to calculate ceil(log()) on
* @return uint256 Output value
*/
function ceilLog10(
uint256 _value
)
internal
pure
returns (uint256)
{
// Make sure passed value is greater than 0
require (
_value > 0,
"CommonMath.ceilLog10: Value must be greater than zero."
);
// Since log10(1) = 0, if _value = 1 return 0
if (_value == 1) return 0;
// Calcualte ceil(log10())
uint256 x = _value - 1;
uint256 result = 0;
if (x >= 10 ** 64) {
x /= 10 ** 64;
result += 64;
}
if (x >= 10 ** 32) {
x /= 10 ** 32;
result += 32;
}
if (x >= 10 ** 16) {
x /= 10 ** 16;
result += 16;
}
if (x >= 10 ** 8) {
x /= 10 ** 8;
result += 8;
}
if (x >= 10 ** 4) {
x /= 10 ** 4;
result += 4;
}
if (x >= 100) {
x /= 100;
result += 2;
}
if (x >= 10) {
result += 1;
}
return result + 1;
}
}
// File: contracts/core/interfaces/ICore.sol
/*
Copyright 2018 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
/**
* @title ICore
* @author Set Protocol
*
* The ICore Contract defines all the functions exposed in the Core through its
* various extensions and is a light weight way to interact with the contract.
*/
interface ICore {
/**
* Return transferProxy address.
*
* @return address transferProxy address
*/
function transferProxy()
external
view
returns (address);
/**
* Return vault address.
*
* @return address vault address
*/
function vault()
external
view
returns (address);
/**
* Return address belonging to given exchangeId.
*
* @param _exchangeId ExchangeId number
* @return address Address belonging to given exchangeId
*/
function exchangeIds(
uint8 _exchangeId
)
external
view
returns (address);
/*
* Returns if valid set
*
* @return bool Returns true if Set created through Core and isn't disabled
*/
function validSets(address)
external
view
returns (bool);
/*
* Returns if valid module
*
* @return bool Returns true if valid module
*/
function validModules(address)
external
view
returns (bool);
/**
* Return boolean indicating if address is a valid Rebalancing Price Library.
*
* @param _priceLibrary Price library address
* @return bool Boolean indicating if valid Price Library
*/
function validPriceLibraries(
address _priceLibrary
)
external
view
returns (bool);
/**
* Exchanges components for Set Tokens
*
* @param _set Address of set to issue
* @param _quantity Quantity of set to issue
*/
function issue(
address _set,
uint256 _quantity
)
external;
/**
* Issues a specified Set for a specified quantity to the recipient
* using the caller's components from the wallet and vault.
*
* @param _recipient Address to issue to
* @param _set Address of the Set to issue
* @param _quantity Number of tokens to issue
*/
function issueTo(
address _recipient,
address _set,
uint256 _quantity
)
external;
/**
* Converts user's components into Set Tokens held directly in Vault instead of user's account
*
* @param _set Address of the Set
* @param _quantity Number of tokens to redeem
*/
function issueInVault(
address _set,
uint256 _quantity
)
external;
/**
* Function to convert Set Tokens into underlying components
*
* @param _set The address of the Set token
* @param _quantity The number of tokens to redeem. Should be multiple of natural unit.
*/
function redeem(
address _set,
uint256 _quantity
)
external;
/**
* Redeem Set token and return components to specified recipient. The components
* are left in the vault
*
* @param _recipient Recipient of Set being issued
* @param _set Address of the Set
* @param _quantity Number of tokens to redeem
*/
function redeemTo(
address _recipient,
address _set,
uint256 _quantity
)
external;
/**
* Function to convert Set Tokens held in vault into underlying components
*
* @param _set The address of the Set token
* @param _quantity The number of tokens to redeem. Should be multiple of natural unit.
*/
function redeemInVault(
address _set,
uint256 _quantity
)
external;
/**
* Composite method to redeem and withdraw with a single transaction
*
* Normally, you should expect to be able to withdraw all of the tokens.
* However, some have central abilities to freeze transfers (e.g. EOS). _toExclude
* allows you to optionally specify which component tokens to exclude when
* redeeming. They will remain in the vault under the users' addresses.
*
* @param _set Address of the Set
* @param _to Address to withdraw or attribute tokens to
* @param _quantity Number of tokens to redeem
* @param _toExclude Mask of indexes of tokens to exclude from withdrawing
*/
function redeemAndWithdrawTo(
address _set,
address _to,
uint256 _quantity,
uint256 _toExclude
)
external;
/**
* Deposit multiple tokens to the vault. Quantities should be in the
* order of the addresses of the tokens being deposited.
*
* @param _tokens Array of the addresses of the ERC20 tokens
* @param _quantities Array of the number of tokens to deposit
*/
function batchDeposit(
address[] calldata _tokens,
uint256[] calldata _quantities
)
external;
/**
* Withdraw multiple tokens from the vault. Quantities should be in the
* order of the addresses of the tokens being withdrawn.
*
* @param _tokens Array of the addresses of the ERC20 tokens
* @param _quantities Array of the number of tokens to withdraw
*/
function batchWithdraw(
address[] calldata _tokens,
uint256[] calldata _quantities
)
external;
/**
* Deposit any quantity of tokens into the vault.
*
* @param _token The address of the ERC20 token
* @param _quantity The number of tokens to deposit
*/
function deposit(
address _token,
uint256 _quantity
)
external;
/**
* Withdraw a quantity of tokens from the vault.
*
* @param _token The address of the ERC20 token
* @param _quantity The number of tokens to withdraw
*/
function withdraw(
address _token,
uint256 _quantity
)
external;
/**
* Transfer tokens associated with the sender's account in vault to another user's
* account in vault.
*
* @param _token Address of token being transferred
* @param _to Address of user receiving tokens
* @param _quantity Amount of tokens being transferred
*/
function internalTransfer(
address _token,
address _to,
uint256 _quantity
)
external;
/**
* Deploys a new Set Token and adds it to the valid list of SetTokens
*
* @param _factory The address of the Factory to create from
* @param _components The address of component tokens
* @param _units The units of each component token
* @param _naturalUnit The minimum unit to be issued or redeemed
* @param _name The bytes32 encoded name of the new Set
* @param _symbol The bytes32 encoded symbol of the new Set
* @param _callData Byte string containing additional call parameters
* @return setTokenAddress The address of the new Set
*/
function createSet(
address _factory,
address[] calldata _components,
uint256[] calldata _units,
uint256 _naturalUnit,
bytes32 _name,
bytes32 _symbol,
bytes calldata _callData
)
external
returns (address);
/**
* Exposes internal function that deposits a quantity of tokens to the vault and attributes
* the tokens respectively, to system modules.
*
* @param _from Address to transfer tokens from
* @param _to Address to credit for deposit
* @param _token Address of token being deposited
* @param _quantity Amount of tokens to deposit
*/
function depositModule(
address _from,
address _to,
address _token,
uint256 _quantity
)
external;
/**
* Exposes internal function that withdraws a quantity of tokens from the vault and
* deattributes the tokens respectively, to system modules.
*
* @param _from Address to decredit for withdraw
* @param _to Address to transfer tokens to
* @param _token Address of token being withdrawn
* @param _quantity Amount of tokens to withdraw
*/
function withdrawModule(
address _from,
address _to,
address _token,
uint256 _quantity
)
external;
/**
* Exposes internal function that deposits multiple tokens to the vault, to system
* modules. Quantities should be in the order of the addresses of the tokens being
* deposited.
*
* @param _from Address to transfer tokens from
* @param _to Address to credit for deposits
* @param _tokens Array of the addresses of the tokens being deposited
* @param _quantities Array of the amounts of tokens to deposit
*/
function batchDepositModule(
address _from,
address _to,
address[] calldata _tokens,
uint256[] calldata _quantities
)
external;
/**
* Exposes internal function that withdraws multiple tokens from the vault, to system
* modules. Quantities should be in the order of the addresses of the tokens being withdrawn.
*
* @param _from Address to decredit for withdrawals
* @param _to Address to transfer tokens to
* @param _tokens Array of the addresses of the tokens being withdrawn
* @param _quantities Array of the amounts of tokens to withdraw
*/
function batchWithdrawModule(
address _from,
address _to,
address[] calldata _tokens,
uint256[] calldata _quantities
)
external;
/**
* Expose internal function that exchanges components for Set tokens,
* accepting any owner, to system modules
*
* @param _owner Address to use tokens from
* @param _recipient Address to issue Set to
* @param _set Address of the Set to issue
* @param _quantity Number of tokens to issue
*/
function issueModule(
address _owner,
address _recipient,
address _set,
uint256 _quantity
)
external;
/**
* Expose internal function that exchanges Set tokens for components,
* accepting any owner, to system modules
*
* @param _burnAddress Address to burn token from
* @param _incrementAddress Address to increment component tokens to
* @param _set Address of the Set to redeem
* @param _quantity Number of tokens to redeem
*/
function redeemModule(
address _burnAddress,
address _incrementAddress,
address _set,
uint256 _quantity
)
external;
/**
* Expose vault function that increments user's balance in the vault.
* Available to system modules
*
* @param _tokens The addresses of the ERC20 tokens
* @param _owner The address of the token owner
* @param _quantities The numbers of tokens to attribute to owner
*/
function batchIncrementTokenOwnerModule(
address[] calldata _tokens,
address _owner,
uint256[] calldata _quantities
)
external;
/**
* Expose vault function that decrement user's balance in the vault
* Only available to system modules.
*
* @param _tokens The addresses of the ERC20 tokens
* @param _owner The address of the token owner
* @param _quantities The numbers of tokens to attribute to owner
*/
function batchDecrementTokenOwnerModule(
address[] calldata _tokens,
address _owner,
uint256[] calldata _quantities
)
external;
/**
* Expose vault function that transfer vault balances between users
* Only available to system modules.
*
* @param _tokens Addresses of tokens being transferred
* @param _from Address tokens being transferred from
* @param _to Address tokens being transferred to
* @param _quantities Amounts of tokens being transferred
*/
function batchTransferBalanceModule(
address[] calldata _tokens,
address _from,
address _to,
uint256[] calldata _quantities
)
external;
/**
* Transfers token from one address to another using the transfer proxy.
* Only available to system modules.
*
* @param _token The address of the ERC20 token
* @param _quantity The number of tokens to transfer
* @param _from The address to transfer from
* @param _to The address to transfer to
*/
function transferModule(
address _token,
uint256 _quantity,
address _from,
address _to
)
external;
/**
* Expose transfer proxy function to transfer tokens from one address to another
* Only available to system modules.
*
* @param _tokens The addresses of the ERC20 token
* @param _quantities The numbers of tokens to transfer
* @param _from The address to transfer from
* @param _to The address to transfer to
*/
function batchTransferModule(
address[] calldata _tokens,
uint256[] calldata _quantities,
address _from,
address _to
)
external;
}
// File: contracts/core/interfaces/IFeeCalculator.sol
/*
Copyright 2019 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
/**
* @title IFeeCalculator
* @author Set Protocol
*
*/
interface IFeeCalculator {
/* ============ External Functions ============ */
function initialize(
bytes calldata _feeCalculatorData
)
external;
function getFee()
external
view
returns(uint256);
}
// File: contracts/core/interfaces/ISetToken.sol
/*
Copyright 2018 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
/**
* @title ISetToken
* @author Set Protocol
*
* The ISetToken interface provides a light-weight, structured way to interact with the
* SetToken contract from another contract.
*/
interface ISetToken {
/* ============ External Functions ============ */
/*
* Get natural unit of Set
*
* @return uint256 Natural unit of Set
*/
function naturalUnit()
external
view
returns (uint256);
/*
* Get addresses of all components in the Set
*
* @return componentAddresses Array of component tokens
*/
function getComponents()
external
view
returns (address[] memory);
/*
* Get units of all tokens in Set
*
* @return units Array of component units
*/
function getUnits()
external
view
returns (uint256[] memory);
/*
* Checks to make sure token is component of Set
*
* @param _tokenAddress Address of token being checked
* @return bool True if token is component of Set
*/
function tokenIsComponent(
address _tokenAddress
)
external
view
returns (bool);
/*
* Mint set token for given address.
* Can only be called by authorized contracts.
*
* @param _issuer The address of the issuing account
* @param _quantity The number of sets to attribute to issuer
*/
function mint(
address _issuer,
uint256 _quantity
)
external;
/*
* Burn set token for given address
* Can only be called by authorized contracts
*
* @param _from The address of the redeeming account
* @param _quantity The number of sets to burn from redeemer
*/
function burn(
address _from,
uint256 _quantity
)
external;
/**
* Transfer token for a specified address
*
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(
address to,
uint256 value
)
external;
}
// File: contracts/core/lib/SetTokenLibrary.sol
/*
Copyright 2018 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
library SetTokenLibrary {
using SafeMath for uint256;
struct SetDetails {
uint256 naturalUnit;
address[] components;
uint256[] units;
}
/**
* Validates that passed in tokens are all components of the Set
*
* @param _set Address of the Set
* @param _tokens List of tokens to check
*/
function validateTokensAreComponents(
address _set,
address[] calldata _tokens
)
external
view
{
for (uint256 i = 0; i < _tokens.length; i++) {
// Make sure all tokens are members of the Set
require(
ISetToken(_set).tokenIsComponent(_tokens[i]),
"SetTokenLibrary.validateTokensAreComponents: Component must be a member of Set"
);
}
}
/**
* Validates that passed in quantity is a multiple of the natural unit of the Set.
*
* @param _set Address of the Set
* @param _quantity Quantity to validate
*/
function isMultipleOfSetNaturalUnit(
address _set,
uint256 _quantity
)
external
view
{
require(
_quantity.mod(ISetToken(_set).naturalUnit()) == 0,
"SetTokenLibrary.isMultipleOfSetNaturalUnit: Quantity is not a multiple of nat unit"
);
}
/**
* Validates that passed in quantity is a multiple of the natural unit of the Set.
*
* @param _core Address of Core
* @param _set Address of the Set
*/
function requireValidSet(
ICore _core,
address _set
)
internal
view
{
require(
_core.validSets(_set),
"SetTokenLibrary: Must be an approved SetToken address"
);
}
/**
* Retrieves the Set's natural unit, components, and units.
*
* @param _set Address of the Set
* @return SetDetails Struct containing the natural unit, components, and units
*/
function getSetDetails(
address _set
)
internal
view
returns (SetDetails memory)
{
// Declare interface variables
ISetToken setToken = ISetToken(_set);
// Fetch set token properties
uint256 naturalUnit = setToken.naturalUnit();
address[] memory components = setToken.getComponents();
uint256[] memory units = setToken.getUnits();
return SetDetails({
naturalUnit: naturalUnit,
components: components,
units: units
});
}
}
// File: contracts/lib/ScaleValidations.sol
/*
Copyright 2019 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
library ScaleValidations {
using SafeMath for uint256;
uint256 private constant ONE_HUNDRED_PERCENT = 1e18;
uint256 private constant ONE_BASIS_POINT = 1e14;
function validateLessThanEqualOneHundredPercent(uint256 _value) internal view {
require(_value <= ONE_HUNDRED_PERCENT, "Must be <= 100%");
}
function validateMultipleOfBasisPoint(uint256 _value) internal view {
require(
_value.mod(ONE_BASIS_POINT) == 0,
"Must be multiple of 0.01%"
);
}
}
// File: contracts/core/fee-calculators/FixedFeeCalculator.sol
/*
Copyright 2019 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
/**
* @title FixedFeeCalculator
* @author Set Protocol
*
* Smart contract that stores and returns fees (represented as scaled decimal values).
* Meant to be used with a RebalancingSetTokenV2
*/
contract FixedFeeCalculator is IFeeCalculator {
using SafeMath for uint256;
/* ============ State Variables ============ */
// Mapping between an address and its initialization state
mapping(address => bool) public isInitialized;
// Mapping between an address and its current fee
mapping(address => uint256) public fees;
/* ============ External Functions ============ */
/**
* Initializes the rebalance fee for the caller. Fee is represented as a scaled decimal value.
* (e.g. 1% = 10 ** 18, 0.1% = 10 ** 17)
* Intended to be called by a RebalancingSetTokenV2 during initialization.
*
* @param _feeCalculatorData Bytes encoded data about the fee for the sender
*/
function initialize(
bytes calldata _feeCalculatorData
)
external
{
// Sender fee must not already be initialized
require(!isInitialized[msg.sender], "Must not be initialized");
uint256 fee = parseFeeCalculatorData(_feeCalculatorData);
validateFee(fee);
fees[msg.sender] = fee;
isInitialized[msg.sender] = true;
}
/**
* Returns the fee initialized by the sender. Implicitly returns 0 if the fee has not bee initialized.
*/
function getFee()
external
view
returns(uint256)
{
return fees[msg.sender];
}
/* ============ Private Functions ============ */
/**
* Fee should not exceed 100% and should be a multiple of a basis point.
*
* @param _fee Fee value represented as scaled value
*/
function validateFee(
uint256 _fee
)
private
view
{
ScaleValidations.validateLessThanEqualOneHundredPercent(_fee);
ScaleValidations.validateMultipleOfBasisPoint(_fee);
}
/**
* Function to convert the feeCalculator bytes data to the fee
*
* @param _feeCalculatorData Bytes encoded data about the fee for the sender
* @return _fee Parsed fee value represented as scaled value
*/
function parseFeeCalculatorData(
bytes memory _feeCalculatorData
)
private
pure
returns (uint256)
{
uint256 fee;
assembly {
fee := mload(add(_feeCalculatorData, 32))
}
return fee;
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"constant":false,"inputs":[{"name":"_feeCalculatorData","type":"bytes"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getFee","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"isInitialized","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"fees","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
32095:2452:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;32095:2452:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32857:406;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;32857:406:0;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;32857:406:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;32857:406:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;32857:406:0;;-1:-1:-1;32857:406:0;-1:-1:-1;32857:406:0;:::i;:::-;;33397:123;;;:::i;:::-;;;;;;;;;;;;;;;;32302:45;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32302:45:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;32411:39;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32411:39:0;;;;:::i;32857:406::-;33040:10;33026:13;:25;;;;;;;;;;;;;33025:26;33017:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33092:11;33106:42;33129:18;;33106:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;33106:22:0;;-1:-1:-1;;;33106:42:0:i;:::-;33092:56;;33161:16;33173:3;33161:11;:16::i;:::-;33195:10;33190:16;;;;:4;:16;;;;;;;;:22;;;;33223:25;;;;;;:32;;-1:-1:-1;;33223:32:0;;;;;;-1:-1:-1;;32857:406:0:o;33397:123::-;33501:10;33464:7;33496:16;;;:4;:16;;;;;;33397:123;:::o;32302:45::-;;;;;;;;;;;;;;;;:::o;32411:39::-;;;;;;;;;;;;;:::o;34259:285::-;34499:2;34475:27;34469:34;;34259:285::o;33753:231::-;33851:61;33907:4;33851:55;:61::i;:::-;33925:51;33971:4;33925:45;:51::i;:::-;33753:231;:::o;30806:154::-;30739:4;30903:6;:29;;30895:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30968:194;31069:27;:6;30793:4;31069:27;:10;:27;:::i;:::-;:32;31047:107;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1861:124;1919:7;1947:6;1939:15;;;;;;1976:1;1972;:5;;;;;;;1861:124;-1:-1:-1;;;1861:124:0:o
Swarm Source
bzzr://4514786589477eb22ed77e17114ea813cd806bf116c48f817f8bf876bd5e4e58
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.