Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 1,020 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Claim | 20594630 | 5 days ago | IN | 0 ETH | 0.0001203 | ||||
Claim And Unstak... | 20060750 | 79 days ago | IN | 0 ETH | 0.00062255 | ||||
Claim | 19740139 | 124 days ago | IN | 0 ETH | 0.00130313 | ||||
Claim And Unstak... | 19617004 | 141 days ago | IN | 0 ETH | 0.00189622 | ||||
Claim And Unstak... | 18417585 | 309 days ago | IN | 0 ETH | 0.00386827 | ||||
Claim And Unstak... | 18412819 | 310 days ago | IN | 0 ETH | 0.0012731 | ||||
Claim And Unstak... | 18184585 | 342 days ago | IN | 0 ETH | 0.00306805 | ||||
Claim And Unstak... | 17415041 | 450 days ago | IN | 0 ETH | 0.00485499 | ||||
Claim And Unstak... | 16816158 | 534 days ago | IN | 0 ETH | 0.00301643 | ||||
Claim And Unstak... | 16322237 | 604 days ago | IN | 0 ETH | 0.00187954 | ||||
Claim And Unstak... | 16231339 | 616 days ago | IN | 0 ETH | 0.00159869 | ||||
Claim And Unstak... | 16198797 | 621 days ago | IN | 0 ETH | 0.00288427 | ||||
Claim And Unstak... | 16094821 | 635 days ago | IN | 0 ETH | 0.00150188 | ||||
Claim And Unstak... | 15975079 | 652 days ago | IN | 0 ETH | 0.00159864 | ||||
Claim | 15974940 | 652 days ago | IN | 0 ETH | 0.00123136 | ||||
Claim And Unstak... | 15956294 | 655 days ago | IN | 0 ETH | 0.00151168 | ||||
Claim | 15787016 | 678 days ago | IN | 0 ETH | 0.00182551 | ||||
Claim And Unstak... | 15786619 | 678 days ago | IN | 0 ETH | 0.00155768 | ||||
Claim | 15786508 | 678 days ago | IN | 0 ETH | 0.00198716 | ||||
Claim And Unstak... | 15786505 | 678 days ago | IN | 0 ETH | 0.00170176 | ||||
Claim | 15406029 | 734 days ago | IN | 0 ETH | 0.00065626 | ||||
Claim And Unstak... | 15393450 | 736 days ago | IN | 0 ETH | 0.00259898 | ||||
Claim And Unstak... | 15235249 | 761 days ago | IN | 0 ETH | 0.00122561 | ||||
Claim And Unstak... | 15165496 | 772 days ago | IN | 0 ETH | 0.00217578 | ||||
Claim And Unstak... | 14978957 | 803 days ago | IN | 0 ETH | 0.00218054 |
Latest 3 internal transactions
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
10950208 | 1430 days ago | Contract Creation | 0 ETH | |||
10950208 | 1430 days ago | Contract Creation | 0 ETH | |||
10950208 | 1430 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x47B35E06...c2cf7d87A The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
IncrementalStaking
Compiler Version
v0.6.10+commit.00c0fcaf
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-09-29 */ // File: @openzeppelin/contracts/math/SafeMath.sol // SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot 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-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol pragma solidity ^0.6.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } // File: @openzeppelin/contracts/utils/Address.sol pragma solidity ^0.6.2; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: contracts/Ownable.sol pragma solidity 0.6.10; /** * @title Ownable * @dev The Ownable contract has an owner address, and provides basic authorization control * functions, this simplifies the implementation of "user permissions". */ contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev The Ownable constructor sets the original `owner` of the contract to the a * specified account. * @param initalOwner The address of the inital owner. */ constructor(address initalOwner) internal { _owner = initalOwner; emit OwnershipTransferred(address(0), _owner); } /** * @return the address of the owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(isOwner(), "Only owner can call"); _; } /** * @return true if `msg.sender` is the owner of the contract. */ function isOwner() public view returns (bool) { return msg.sender == _owner; } /** * @dev Allows the current owner to relinquish control of the contract. * It will not be possible to call the functions with the `onlyOwner` * modifier anymore. * @notice Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Allows the current owner to transfer control of the contract to a newOwner. * @param newOwner The address to transfer ownership to. */ function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } /** * @dev Transfers control of the contract to a newOwner. * @param newOwner The address to transfer ownership to. */ function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Owner should not be 0 address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: contracts/TokenPool.sol pragma solidity 0.6.10; /** * @title A simple holder of tokens. * This is a simple contract to hold tokens. It's useful in the case where a separate contract * needs to hold multiple distinct pools of the same token. */ contract TokenPool is Ownable { IERC20 public token; constructor(IERC20 _token) Ownable(msg.sender) public { token = _token; } function balance() public view returns (uint256) { return token.balanceOf(address(this)); } function transfer(address to, uint256 value) external onlyOwner returns (bool) { return token.transfer(to, value); } } // File: contracts/AbstractStaking.sol pragma solidity 0.6.10; /** * @title Abstract Staking * @dev Skeleton of the staking pool for user to stake Balancer BPT token and get bella as reward. */ abstract contract AbstractStaking is Ownable { using SafeMath for uint256; event Staked(address indexed user, uint256 amount); event Unstaked(address indexed user, uint256 amount); event Claimed(address indexed user, uint256 amount); TokenPool public stakingPool; TokenPool public lockedPool; TokenPool public unlockedPool; uint256 public startTime; // // Global state // uint256 public totalStakingAmount; uint256 public totalStakingAmountTime; // total time * amount staked uint256 public lastUpdatedTimestamp; // // Addional bella locking related // uint256 public currentUnlockCycle; // linear count down to release bella token uint256 public lastUnlockTime; /** * @param stakingBPT The BPT token users deposit as stake. * @param bellaToken The bonus token is bella. * @param admin The admin address * @param _startTime Timestamp that user can stake */ constructor( IERC20 stakingBPT, IERC20 bellaToken, address admin, uint256 _startTime ) Ownable(admin) internal { stakingPool = new TokenPool(stakingBPT); lockedPool = new TokenPool(bellaToken); unlockedPool = new TokenPool(bellaToken); startTime = _startTime; } /** * @return The user's total staking BPT amount */ function totalStakedFor(address user) public view virtual returns (uint256); function totalStaked() public view returns (uint256) { return totalStakingAmount; } /** * @dev Stake for the user self * @param amount The amount of BPT tokens that the user wishes to stake */ function stake(uint256 amount) external { require(!Address.isContract(msg.sender), "No harvest thanks"); require(now >= startTime, "not started yet"); _stake(msg.sender, msg.sender, amount); } /** * @return User's total rewards when clamining */ function totalRewards() external view returns (uint256) { return _totalRewardsFor(msg.sender); } /** * @return A specific user's total rewards when clamining */ function totalRewardsFor(address user) external view returns (uint256) { return _totalRewardsFor(user); } /** * @dev Claim=withdraw all the bella rewards */ function claim() external { require(!Address.isContract(msg.sender), "No harvest thanks"); // cumulate user and global time*amount _updateTotalStaking(0); _updateUserStaking(0, msg.sender); _poolUnlock(); uint256 reward = _calculateRewardAndBurnAll(msg.sender); unlockedPool.transfer(msg.sender, reward); emit Claimed(msg.sender, reward); } /** * @dev Claim=withdraw all the bella rewards and the staking BPT token, * which stops the user's staking */ function claimAndUnstake() external { require(!Address.isContract(msg.sender), "No harvest thanks"); // cumulate user and global time*amount _updateTotalStaking(0); _updateUserStaking(0, msg.sender); _poolUnlock(); (uint256 staking, uint256 reward) = _calculateRewardAndCleanUser(msg.sender); unlockedPool.transfer(msg.sender, reward); stakingPool.transfer(msg.sender, staking); emit Claimed(msg.sender, reward); emit Unstaked(msg.sender, staking); } /** * @dev we will lock more bella tokens on the begining of the next releasing cycle * @param amount the amount of bella token to lock * @param nextUnlockCycle next reward releasing cycle, unit=day */ function lock(uint256 amount, uint256 nextUnlockCycle) external onlyOwner { currentUnlockCycle = nextUnlockCycle * 1 days; if (now >= startTime) { lastUnlockTime = now; } else { lastUnlockTime = startTime; } require( lockedPool.token().transferFrom(msg.sender, address(lockedPool), amount), "Additional bella transfer failed" ); } /** * @dev Actual logic to handle user staking * @param from The user who pays the staking BPT * @param beneficiary The user who actually controls the staking BPT * @param amount The amount of BPT tokens to stake */ function _stake(address from, address beneficiary, uint256 amount) private { require(amount > 0, "can not stake 0 token"); require( stakingPool.token().transferFrom(from, address(stakingPool), amount), "Staking BPT transfer failed" ); _updateUserStaking(amount, beneficiary); _updateTotalStaking(amount); emit Staked(beneficiary, amount); } /** * @dev Update the global state due to more time cumulated and/or new BPT staking token * @param amount New BPT staking deposited (can be 0) */ function _updateTotalStaking(uint256 amount) private { uint256 additionalAmountTime = totalStakingAmount.mul(now.sub(lastUpdatedTimestamp)); totalStakingAmount = totalStakingAmount.add(amount); totalStakingAmountTime = totalStakingAmountTime.add(additionalAmountTime); lastUpdatedTimestamp = now; } /** * @dev Update a specific user's state due to more time cumulated and/or new BPT staking token * @param amount New BPT staking deposited (can be 0) * @param user The account to be updated */ function _updateUserStaking(uint256 amount, address user) internal virtual; /** * @dev linear count down from 30 days to release bella token, * from the locked pool to the unlocked pool */ function _poolUnlock() private { if (currentUnlockCycle == 0) return; // release ended uint256 timeDelta = now.sub(lastUnlockTime); if (currentUnlockCycle < timeDelta) currentUnlockCycle = timeDelta; // release all uint256 amount = lockedPool.balance().mul(timeDelta).div(currentUnlockCycle); currentUnlockCycle = currentUnlockCycle.sub(timeDelta); lastUnlockTime = now; lockedPool.transfer(address(unlockedPool), amount); } /** * @dev Calculate user's total cumulated reward and burn his/her all staking amount*time * @return User cumulated reward bella during the staking process */ function _calculateRewardAndBurnAll(address user) internal virtual returns (uint256); /** * @dev Calculate user's total cumulated reward and staking, * and remove him/her from the staking process * @return [1] User cumulated staking BPT * @return [2] User cumulated reward bella during the staking process */ function _calculateRewardAndCleanUser(address user) internal virtual returns (uint256, uint256); /** * @dev Internal function to calculate user's total rewards * @return A specific user's total rewards when clamining */ function _totalRewardsFor(address user) internal view virtual returns (uint256); } // File: contracts/IncrementalStaking.sol pragma solidity 0.6.10; /** * @title Incremental Staking * @dev A staking pool for user to stake Balancer BPT token and get bella as reward. * Regarding the staking time, there is a linear bonus amplifier goes from 1.0 (initially) * to 2.0 (at the end of the 60th day). The reward is added by the admin at the 0th, 30th * and 60th day, respectively. * @notice If the user stakes too many times (which is irrational considiering the gas fee), * he will get stuck later */ contract IncrementalStaking is AbstractStaking { using SafeMath for uint256; mapping(address=>Staking[]) public stakingInfo; struct Staking { uint256 amount; uint256 time; } // // Reward amplifier related // uint256 constant STARTING_BONUS = 5_000; uint256 constant ENDING_BONUS = 10_000; uint256 constant ONE = 10_000; uint256 constant BONUS_PERIOD = 60 days; /** * @param stakingBPT The BPT token users deposit as stake. * @param bellaToken The bonus token is bella. * @param admin The admin address * @param _startTime Timestamp that user can stake */ constructor( IERC20 stakingBPT, IERC20 bellaToken, address admin, uint256 _startTime ) AbstractStaking( stakingBPT, bellaToken, admin, _startTime ) public {} /** * @return The user's total staking BPT amount */ function totalStakedFor(address user) public view override returns (uint256) { uint amount = 0; Staking[] memory userStaking = stakingInfo[user]; for (uint256 i=0; i < userStaking.length; i++) { amount = amount.add(userStaking[i].amount); } return amount; } /** * @dev Update a specific user's state due to more time cumulated and/or new BPT staking token * @param amount New BPT staking deposited (can be 0) * @param user The account to be updated */ function _updateUserStaking(uint256 amount, address user) internal override { if (amount == 0) return; Staking memory newStaking = Staking({amount: amount, time: now}); stakingInfo[user].push(newStaking); } /** * @dev Calculate user's total cumulated reward and burn his/her all staking amount*time * @return User cumulated reward bella during the staking process */ function _calculateRewardAndBurnAll(address user) internal override returns (uint256) { uint256 totalReward = 0; uint256 totalStaking = 0; uint256 totalTimeAmount = 0; Staking[] memory userStakings = stakingInfo[user]; // iterate through user's staking for (uint256 i=0; i<userStakings.length; i++) { totalStaking = totalStaking.add(userStakings[i].amount); // get the staking part's reward (amplified) and the time*amount to reduce (uint256 reward, uint256 timeAmount) = _getRewardAndTimeAmountToBurn(userStakings[i]); totalReward = totalReward.add(reward); totalTimeAmount = totalTimeAmount.add(timeAmount); } totalStakingAmountTime = totalStakingAmountTime.sub(totalTimeAmount); // user staking information reset delete stakingInfo[user]; stakingInfo[user].push(Staking({amount: totalStaking, time: now})); return totalReward; } /** * @dev Calculate user's total cumulated reward and staking, * and remove him/her from the staking process * @return [1] User cumulated staking BPT * @return [2] User cumulated reward bella during the staking process */ function _calculateRewardAndCleanUser(address user) internal override returns (uint256, uint256) { uint256 totalStaking = 0; uint256 totalReward = 0; uint256 totalTimeAmount = 0; Staking[] memory userStakings = stakingInfo[user]; // iterate through user's staking for (uint256 i=0; i<userStakings.length; i++) { totalStaking = totalStaking.add(userStakings[i].amount); // get the staking part's reward (amplified) and the time*amount to reduce (uint256 reward, uint256 timeAmount) = _getRewardAndTimeAmountToBurn(userStakings[i]); totalReward = totalReward.add(reward); totalTimeAmount = totalTimeAmount.add(timeAmount); } totalStakingAmount = totalStakingAmount.sub(totalStaking); totalStakingAmountTime = totalStakingAmountTime.sub(totalTimeAmount); // clear user delete stakingInfo[user]; return (totalStaking, totalReward); } /** * @dev Calculate user's reward of one portion of stake amplified * @return [1] Reward of this portion of stake * @return [2] Time*amount to burn */ function _getRewardAndTimeAmountToBurn(Staking memory staking) private view returns (uint256, uint256) { uint256 timeDelta = now.sub(staking.time); uint256 timeAmount = staking.amount.mul(timeDelta); uint256 rewardFullBonus = unlockedPool.balance().mul(timeAmount).div(totalStakingAmountTime); if (timeDelta >= BONUS_PERIOD) return (rewardFullBonus, timeAmount); uint256 reward = (ENDING_BONUS - STARTING_BONUS).mul(timeDelta).div(BONUS_PERIOD).add(STARTING_BONUS).mul(rewardFullBonus).div(ONE); return (reward, timeAmount); } /** * @dev Internal function to calculate user's total rewards * @return A specific user's total rewards when clamining */ function _totalRewardsFor(address user) internal view override returns (uint256) { // calculate new total staking amount*time uint256 additionalAmountTime = totalStakingAmount.mul(now.sub(lastUpdatedTimestamp)); uint256 newTotalStakingAmountTime = totalStakingAmountTime.add(additionalAmountTime); // calculate total unlocked pool uint256 unlockedAmount = unlockedPool.balance(); if (currentUnlockCycle != 0) { uint256 timeDelta = now.sub(lastUnlockTime); if (currentUnlockCycle <= timeDelta) { unlockedAmount = unlockedAmount.add(lockedPool.balance()); } else { uint256 additionalAmount = lockedPool.balance().mul(timeDelta).div(currentUnlockCycle); unlockedAmount = unlockedAmount.add(additionalAmount); } } uint256 totalReward = 0; Staking[] memory userStakings = stakingInfo[user]; // iterate through user's staking for (uint256 i=0; i<userStakings.length; i++) { // get the staking part's reward (amplified) and the time*amount to reduce Staking memory staking = userStakings[i]; uint256 timeDelta = now.sub(staking.time); uint256 timeAmount = staking.amount.mul(timeDelta); uint256 reward = unlockedAmount.mul(timeAmount).div(newTotalStakingAmountTime); if (timeDelta < BONUS_PERIOD) reward = (ENDING_BONUS - STARTING_BONUS).mul(timeDelta).div(BONUS_PERIOD).add( STARTING_BONUS).mul(reward).div(ONE); totalReward = totalReward.add(reward); } return totalReward; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract IERC20","name":"stakingBPT","type":"address"},{"internalType":"contract IERC20","name":"bellaToken","type":"address"},{"internalType":"address","name":"admin","type":"address"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unstaked","type":"event"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimAndUnstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentUnlockCycle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUnlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdatedTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"nextUnlockCycle","type":"uint256"}],"name":"lock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lockedPool","outputs":[{"internalType":"contract TokenPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakingInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"time","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingPool","outputs":[{"internalType":"contract TokenPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"totalRewardsFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"totalStakedFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStakingAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStakingAmountTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unlockedPool","outputs":[{"internalType":"contract TokenPool","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Deployed Bytecode
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
Deployed Bytecode Sourcemap
25649:7030:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18036:28;;;:::i;:::-;;;;-1:-1:-1;;;;;18036:28:0;;;;;;;;;;;;;;19835:110;;;:::i;:::-;;;;;;;;;;;;;;;;21588:455;;;;;;;;;;;;;;;;-1:-1:-1;21588:455:0;;;;;;;:::i;:::-;;18253:37;;;:::i;26672:320::-;;;;;;;;;;;;;;;;-1:-1:-1;26672:320:0;-1:-1:-1;;;;;26672:320:0;;:::i;20229:425::-;;;:::i;18071:27::-;;;:::i;16071:140::-;;;:::i;18143:24::-;;;:::i;20034:119::-;;;;;;;;;;;;;;;;-1:-1:-1;20034:119:0;-1:-1:-1;;;;;20034:119:0;;:::i;18105:29::-;;;:::i;19296:97::-;;;:::i;15258:79::-;;;:::i;15616:92::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;18510:29;;;:::i;19533:224::-;;;;;;;;;;;;;;;;-1:-1:-1;19533:224:0;;:::i;20796:553::-;;;:::i;18426:33::-;;;:::i;25738:46::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;25738:46:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;18213:33;;;:::i;16388:109::-;;;;;;;;;;;;;;;;-1:-1:-1;16388:109:0;-1:-1:-1;;;;;16388:109:0;;:::i;18327:35::-;;;:::i;18036:28::-;;;-1:-1:-1;;;;;18036:28:0;;:::o;19835:110::-;19882:7;19909:28;19926:10;19909:16;:28::i;:::-;19902:35;;19835:110;;:::o;21588:455::-;15470:9;:7;:9::i;:::-;15462:41;;;;;-1:-1:-1;;;15462:41:0;;;;;;;;;;;;-1:-1:-1;;;15462:41:0;;;;;;;;;;;;;;;21712:6:::1;21694:24:::0;::::1;21673:18;:45:::0;21740:9:::1;::::0;21733:3:::1;:16;21729:128;;21783:3;21766:14;:20:::0;21729:128:::1;;;21836:9;::::0;21819:14:::1;:26:::0;21729:128:::1;21903:10;;;;;;;;;-1:-1:-1::0;;;;;21903:10:0::1;-1:-1:-1::0;;;;;21903:16:0::1;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;21903:18:0;21955:10:::1;::::0;21903:72:::1;::::0;;-1:-1:-1;;;21903:72:0;;21935:10:::1;21903:72;::::0;::::1;::::0;-1:-1:-1;;;;;21955:10:0;;::::1;21903:72:::0;;;;;;;;;;;;:31;;;::::1;::::0;::::1;::::0;:72;;;;;:18:::1;::::0;:72;;;;;;;21955:10:::1;21903:31:::0;:72;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;21903:72:0;21881:154:::1;;;::::0;;-1:-1:-1;;;21881:154:0;;::::1;;::::0;::::1;::::0;;;;;;;::::1;::::0;;;;;;;;;;;;;::::1;;21588:455:::0;;:::o;18253:37::-;;;;:::o;26672:320::-;-1:-1:-1;;;;;26817:17:0;;26740:7;26817:17;;;:11;:17;;;;;;;;26786:48;;;;;;;;;;;;;;;;;26740:7;;26786:28;;:48;26817:17;26786:48;26740:7;;26786:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26786:48:0;;-1:-1:-1;26850:9:0;;-1:-1:-1;;;26845:116:0;26867:11;:18;26863:1;:22;26845:116;;;26916:33;26927:11;26939:1;26927:14;;;;;;;;;;;;;;:21;;;26916:6;:10;;:33;;;;:::i;:::-;26907:42;-1:-1:-1;26887:3:0;;26845:116;;;-1:-1:-1;26978:6:0;;26672:320;-1:-1:-1;;;26672:320:0:o;20229:425::-;20275:30;20294:10;20275:18;:30::i;:::-;20274:31;20266:61;;;;;-1:-1:-1;;;20266:61:0;;;;;;;;;;;;-1:-1:-1;;;20266:61:0;;;;;;;;;;;;;;;20387:22;20407:1;20387:19;:22::i;:::-;20420:33;20439:1;20442:10;20420:18;:33::i;:::-;20466:13;:11;:13::i;:::-;20492:14;20509:38;20536:10;20509:26;:38::i;:::-;20560:12;;:41;;;-1:-1:-1;;;20560:41:0;;20582:10;20560:41;;;;;;;;;;;;20492:55;;-1:-1:-1;;;;;;20560:12:0;;;;:21;;:41;;;;;;;;;;;;;;;:12;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;20619:27:0;;;;;;;;20627:10;;20619:27;;;;;;20560:41;20619:27;;;20229:425;:::o;18071:27::-;;;-1:-1:-1;;;;;18071:27:0;;:::o;16071:140::-;15470:9;:7;:9::i;:::-;15462:41;;;;;-1:-1:-1;;;15462:41:0;;;;;;;;;;;;-1:-1:-1;;;15462:41:0;;;;;;;;;;;;;;;16170:1:::1;16154:6:::0;;16133:40:::1;::::0;-1:-1:-1;;;;;16154:6:0;;::::1;::::0;16133:40:::1;::::0;16170:1;;16133:40:::1;16201:1;16184:19:::0;;-1:-1:-1;;;;;;16184:19:0::1;::::0;;16071:140::o;18143:24::-;;;;:::o;20034:119::-;20096:7;20123:22;20140:4;20123:16;:22::i;:::-;20116:29;20034:119;-1:-1:-1;;20034:119:0:o;18105:29::-;;;-1:-1:-1;;;;;18105:29:0;;:::o;19296:97::-;19367:18;;19296:97;:::o;15258:79::-;15296:7;15323:6;-1:-1:-1;;;;;15323:6:0;15258:79;:::o;15616:92::-;15656:4;15694:6;-1:-1:-1;;;;;15694:6:0;15680:10;:20;;15616:92::o;18510:29::-;;;;:::o;19533:224::-;19593:30;19612:10;19593:18;:30::i;:::-;19592:31;19584:61;;;;;-1:-1:-1;;;19584:61:0;;;;;;;;;;;;-1:-1:-1;;;19584:61:0;;;;;;;;;;;;;;;19671:9;;19664:3;:16;;19656:44;;;;;-1:-1:-1;;;19656:44:0;;;;;;;;;;;;-1:-1:-1;;;19656:44:0;;;;;;;;;;;;;;;19711:38;19718:10;19730;19742:6;19711;:38::i;:::-;19533:224;:::o;20796:553::-;20852:30;20871:10;20852:18;:30::i;:::-;20851:31;20843:61;;;;;-1:-1:-1;;;20843:61:0;;;;;;;;;;;;-1:-1:-1;;;20843:61:0;;;;;;;;;;;;;;;20964:22;20984:1;20964:19;:22::i;:::-;20997:33;21016:1;21019:10;20997:18;:33::i;:::-;21043:13;:11;:13::i;:::-;21070:15;21087:14;21105:40;21134:10;21105:28;:40::i;:::-;21158:12;;:41;;;-1:-1:-1;;;21158:41:0;;21180:10;21158:41;;;;;;;;;;;;21069:76;;-1:-1:-1;21069:76:0;;-1:-1:-1;;;;;;21158:12:0;;:21;;:41;;;;;;;;;;;;;;;:12;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21210:11:0;;:41;;;-1:-1:-1;;;21210:41:0;;21231:10;21210:41;;;;;;;;;;;;-1:-1:-1;;;;;21210:11:0;;;;:20;;:41;;;;;21158;;21210;;;;;;;;:11;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21269:27:0;;;;;;;;21277:10;;21269:27;;;;;;21210:41;21269:27;;;21312:29;;;;;;;;21321:10;;21312:29;;;;;;;;;;20796:553;;:::o;18426:33::-;;;;:::o;25738:46::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25738:46:0;-1:-1:-1;25738:46:0;:::o;18213:33::-;;;;:::o;16388:109::-;15470:9;:7;:9::i;:::-;15462:41;;;;;-1:-1:-1;;;15462:41:0;;;;;;;;;;;;-1:-1:-1;;;15462:41:0;;;;;;;;;;;;;;;16461:28:::1;16480:8;16461:18;:28::i;18327:35::-:0;;;;:::o;30935:1741::-;31007:7;31081:28;31112:53;31135:29;31143:20;;31135:3;:7;;:29;;;;:::i;:::-;31112:18;;;:53;:22;:53;:::i;:::-;31081:84;;31176:33;31212:48;31239:20;31212:22;;:26;;:48;;;;:::i;:::-;31176:84;;31315:22;31340:12;;;;;;;;;-1:-1:-1;;;;;31340:12:0;-1:-1:-1;;;;;31340:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31340:22:0;31377:18;;31340:22;;-1:-1:-1;31377:23:0;31373:441;;31417:17;31437:23;31445:14;;31437:3;:7;;:23;;;;:::i;:::-;31417:43;;31501:9;31479:18;;:31;31475:328;;31567:10;;:20;;;-1:-1:-1;;;31567:20:0;;;;31548:40;;-1:-1:-1;;;;;31567:10:0;;:18;;:20;;;;;;;;;;;;;;:10;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31567:20:0;31548:14;;:40;:18;:40;:::i;:::-;31531:57;;31475:328;;;31629:24;31656:59;31696:18;;31656:35;31681:9;31656:10;;;;;;;;;-1:-1:-1;;;;;31656:10:0;-1:-1:-1;;;;;31656:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31656:20:0;;:35;:24;:35;:::i;:::-;:39;:59;:39;:59;:::i;:::-;31629:86;-1:-1:-1;31751:36:0;:14;31629:86;31751:36;:18;:36;:::i;:::-;31734:53;;31475:328;;31373:441;;-1:-1:-1;;;;;31894:17:0;;31826:19;31894:17;;;:11;:17;;;;;;;;31862:49;;;;;;;;;;;;;;;;;:29;;31826:19;;31862:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31862:49:0;;-1:-1:-1;31972:9:0;;-1:-1:-1;;;31967:671:0;31987:12;:19;31985:1;:21;31967:671;;;32116:22;;:::i;:::-;32141:12;32154:1;32141:15;;;;;;;;;;;;;;32116:40;;32171:17;32191:21;32199:7;:12;;;32191:3;:7;;:21;;;;:::i;:::-;32248:14;;32171:41;;-1:-1:-1;32227:18:0;;32248:29;;32171:41;32248:29;:18;:29;:::i;:::-;32227:50;-1:-1:-1;32294:14:0;32311:61;32346:25;32311:30;:14;32227:50;32311:30;:18;:30;:::i;:61::-;32294:78;;26080:7;32393:9;:24;32389:183;;;32445:127;26035:6;32445:118;32556:6;32445:106;25955:5;32445:64;26080:7;32445:118;25955:5;32481:9;32445:46;:35;:46;:::i;:64::-;:68;:106;:68;:106;:::i;:::-;:110;:118;:110;:118;:::i;:127::-;32436:136;;32389:183;32603:23;:11;32619:6;32603:23;:15;:23;:::i;:::-;32589:37;-1:-1:-1;;32008:3:0;;;;;-1:-1:-1;31967:671:0;;-1:-1:-1;;31967:671:0;;-1:-1:-1;32657:11:0;;30935:1741;-1:-1:-1;;;;;;30935:1741:0:o;956:181::-;1014:7;1046:5;;;1070:6;;;;1062:46;;;;;-1:-1:-1;;;1062:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1128:1;956:181;-1:-1:-1;;;956:181:0:o;8979:619::-;9039:4;9507:20;;9350:66;9547:23;;;;;;:42;;-1:-1:-1;9574:15:0;;;9547:42;9539:51;8979:619;-1:-1:-1;;;;8979:619:0:o;22911:339::-;22975:28;23006:53;23029:29;23037:20;;23029:3;:7;;:29;;;;:::i;23006:53::-;23091:18;;22975:84;;-1:-1:-1;23091:30:0;;23114:6;23091:30;:22;:30;:::i;:::-;23070:18;:51;23157:22;;:48;;23184:20;23157:48;:26;:48;:::i;:::-;23132:22;:73;-1:-1:-1;;23239:3:0;23216:20;:26;22911:339::o;27223:253::-;27314:11;27310:37;;27340:7;;27310:37;27359:25;;:::i;:::-;-1:-1:-1;27387:36:0;;;;;;;;;;;27418:3;27387:36;;;;;;;-1:-1:-1;;;;;27434:17:0;;-1:-1:-1;27434:17:0;;;:11;:17;;;;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27223:253;;:::o;23700:524::-;23746:18;;23742:49;;23784:7;;23742:49;23818:17;23838:23;23846:14;;23838:3;:7;;:23;;;;:::i;:::-;23818:43;;23897:9;23876:18;;:30;23872:79;;;23921:18;:30;;;23872:79;23979:14;23996:59;24036:18;;23996:35;24021:9;23996:10;;;;;;;;;-1:-1:-1;;;;;23996:10:0;-1:-1:-1;;;;;23996:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:59;24089:18;;23979:76;;-1:-1:-1;24089:33:0;;24112:9;24089:33;:22;:33;:::i;:::-;24068:18;:54;24150:3;24133:14;:20;24166:10;;24194:12;;24166:50;;;-1:-1:-1;;;24166:50:0;;-1:-1:-1;;;;;24194:12:0;;;24166:50;;;;;;;;;;;;:10;;;;;:19;;:50;;;;;;;;;;;;;;-1:-1:-1;24166:10:0;:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;23700:524:0;:::o;27667:1029::-;-1:-1:-1;;;;;27915:17:0;;27744:7;27915:17;;;:11;:17;;;;;;;;27883:49;;;;;;;;;;;;;;;;;27744:7;;;;;;27883:29;;:49;;27915:17;;27883:49;27744:7;;27883:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27883:49:0;;-1:-1:-1;27993:9:0;;-1:-1:-1;;;27988:432:0;28008:12;:19;28006:1;:21;27988:432;;;28064:40;28081:12;28094:1;28081:15;;;;;;;;;;;;;;:22;;;28064:12;:16;;:40;;;;:::i;:::-;28049:55;;28208:14;28224:18;28246:46;28276:12;28289:1;28276:15;;;;;;;;;;;;;;28246:29;:46::i;:::-;28207:85;;-1:-1:-1;28207:85:0;-1:-1:-1;28321:23:0;:11;28207:85;28321:23;:15;:23;:::i;:::-;28307:37;-1:-1:-1;28377:31:0;:15;28397:10;28377:31;:19;:31;:::i;:::-;28359:49;-1:-1:-1;;;28029:3:0;;27988:432;;;-1:-1:-1;28457:22:0;;:43;;28484:15;28457:43;:26;:43;:::i;:::-;28432:22;:68;-1:-1:-1;;;;;28563:17:0;;;;;;:11;:17;;;;;28556:24;;;:::i;:::-;-1:-1:-1;;;;;;;28591:17:0;;;;;;:11;:17;;;;;;;;28614:42;;;;;;;;;;;28651:3;28614:42;;;;;;28591:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28677:11;-1:-1:-1;27667:1029:0;;;:::o;22302:431::-;22405:1;22396:6;:10;22388:44;;;;;-1:-1:-1;;;22388:44:0;;;;;;;;;;;;-1:-1:-1;;;22388:44:0;;;;;;;;;;;;;;;22465:11;;;;;;;;;-1:-1:-1;;;;;22465:11:0;-1:-1:-1;;;;;22465:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22465:19:0;22512:11;;22465:68;;;-1:-1:-1;;;22465:68:0;;-1:-1:-1;;;;;22465:68:0;;;;;;;22512:11;;;22465:68;;;;;;;;;;;;:32;;;;;;;:68;;;;;:19;;:68;;;;;;;22512:11;22465:32;:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22465:68:0;22443:145;;;;;-1:-1:-1;;;22443:145:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;22601:39;22620:6;22628:11;22601:18;:39::i;:::-;22653:27;22673:6;22653:19;:27::i;:::-;22698;;;;;;;;-1:-1:-1;;;;;22698:27:0;;;;;;;;;;;;;22302:431;;;:::o;28963:1020::-;-1:-1:-1;;;;;29214:17:0;;29042:7;29214:17;;;:11;:17;;;;;;;;29182:49;;;;;;;;;;;;;;;;;29042:7;;;;;;;;29182:29;;29042:7;;29182:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;29182:49:0;;-1:-1:-1;29292:9:0;;-1:-1:-1;;;29287:432:0;29307:12;:19;29305:1;:21;29287:432;;;29363:40;29380:12;29393:1;29380:15;;;;;;;;;;;;;;:22;;;29363:12;:16;;:40;;;;:::i;:::-;29348:55;;29507:14;29523:18;29545:46;29575:12;29588:1;29575:15;;;;;;;29545:46;29506:85;;-1:-1:-1;29506:85:0;-1:-1:-1;29620:23:0;:11;29506:85;29620:23;:15;:23;:::i;:::-;29606:37;-1:-1:-1;29676:31:0;:15;29696:10;29676:31;:19;:31;:::i;:::-;29658:49;-1:-1:-1;;;29328:3:0;;29287:432;;;-1:-1:-1;29752:18:0;;:36;;29775:12;29752:36;:22;:36;:::i;:::-;29731:18;:57;29824:22;;:43;;29851:15;29824:43;:26;:43;:::i;:::-;29799:22;:68;-1:-1:-1;;;;;29911:17:0;;;;;;:11;:17;;;;;29904:24;;;:::i;:::-;-1:-1:-1;29947:12:0;;-1:-1:-1;29961:11:0;-1:-1:-1;;28963:1020:0;;;;:::o;16647:220::-;-1:-1:-1;;;;;16721:22:0;;16713:64;;;;;-1:-1:-1;;;16713:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;16814:6;;;16793:38;;-1:-1:-1;;;;;16793:38:0;;;;16814:6;;;16793:38;;;16842:6;:17;;-1:-1:-1;;;;;;16842:17:0;-1:-1:-1;;;;;16842:17:0;;;;;;;;;;16647:220::o;1420:136::-;1478:7;1505:43;1509:1;1512;1505:43;;;;;;;;;;;;;;;;;:3;:43::i;2310:471::-;2368:7;2613:6;2609:47;;-1:-1:-1;2643:1:0;2636:8;;2609:47;2680:5;;;2684:1;2680;:5;:1;2704:5;;;;;:10;2696:56;;;;-1:-1:-1;;;2696:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3257:132;3315:7;3342:39;3346:1;3349;3342:39;;;;;;;;;;;;;;;;;:3;:39::i;30173:608::-;30258:7;30267;30287:17;30307:21;30315:7;:12;;;30307:3;:7;;:21;;;;:::i;:::-;30360:14;;30287:41;;-1:-1:-1;30339:18:0;;30360:29;;30287:41;30360:29;:18;:29;:::i;:::-;30339:50;;30402:23;30428:66;30471:22;;30428:38;30455:10;30428:12;;;;;;;;;-1:-1:-1;;;;;30428:12:0;-1:-1:-1;;;;;30428:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:66;30402:92;;26080:7;30511:9;:25;30507:80;;30559:15;-1:-1:-1;30576:10:0;-1:-1:-1;30551:36:0;;-1:-1:-1;30551:36:0;30507:80;30600:14;30617:114;26035:6;30617:105;30706:15;30617:84;25955:5;30617:64;26080:7;30617:105;25955:5;30653:9;30617:46;:35;:46;:::i;:114::-;30600:131;-1:-1:-1;30760:10:0;;-1:-1:-1;;;;30173:608:0;;;:::o;1859:192::-;1945:7;1981:12;1973:6;;;;1965:29;;;;-1:-1:-1;;;1965:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2017:5:0;;;1859:192::o;3885:278::-;3971:7;4006:12;3999:5;3991:28;;;;-1:-1:-1;;;3991:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4030:9;4046:1;4042;:5;;;;;;;3885:278;-1:-1:-1;;;;;3885:278:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Swarm Source
ipfs://b8a9edfb3e987eb82fef67d189942a3339e2e856a087907f517e17273b2d9272
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
BSC | 100.00% | $539.84 | 0.000681 | $0.367631 |
Loading...
Loading
[ Download: CSV Export ]
[ 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.