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
|
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Pausable | contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
/**
* @return true if the contract is paused, false otherwise.
*/
function paused() public view returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!_paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(_paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
} | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | paused | function paused() public view returns (bool) {
return _paused;
}
| /**
* @return true if the contract is paused, false otherwise.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
289,
372
]
} | 13,000 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Pausable | contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
/**
* @return true if the contract is paused, false otherwise.
*/
function paused() public view returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!_paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(_paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
} | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | pause | function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
| /**
* @dev called by the owner to pause, triggers stopped state
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
825,
946
]
} | 13,001 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Pausable | contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
/**
* @return true if the contract is paused, false otherwise.
*/
function paused() public view returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!_paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(_paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
} | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | unpause | function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
| /**
* @dev called by the owner to unpause, returns to normal state
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1036,
1159
]
} | 13,002 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
* @notice Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
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 | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @return the address of the owner.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
457,
541
]
} | 13,003 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
* @notice Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
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 | isOwner | function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
| /**
* @return true if `msg.sender` is the owner of the contract.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
792,
889
]
} | 13,004 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
* @notice Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
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 OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Allows the current owner to relinquish control of the contract.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
* @notice Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1247,
1392
]
} | 13,005 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
* @notice Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
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.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1564,
1678
]
} | 13,006 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
* @notice Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
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.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1823,
2015
]
} | 13,007 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20Destroyable | contract ERC20Destroyable is ERC20, DestroyerRole {
/**
* @dev Function to mint tokens
* @param from The address that will have the tokens destroyed.
* @param value The amount of tokens to destroy.
* @return A boolean that indicates if the operation was successful.
*/
function destroy(address from, uint256 value) public onlyDestroyer returns (bool) {
_burn(from, value);
return true;
}
} | /**
* @title ERC20Destroyable
* @dev ERC20 destroying logic
*/ | NatSpecMultiLine | destroy | function destroy(address from, uint256 value) public onlyDestroyer returns (bool) {
_burn(from, value);
return true;
}
| /**
* @dev Function to mint tokens
* @param from The address that will have the tokens destroyed.
* @param value The amount of tokens to destroy.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
305,
451
]
} | 13,008 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | entryCreditContract | function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
| // Returns _entryCreditContract | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
2163,
2275
]
} | 13,009 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | setEntryCreditContract | function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
| // Set _entryCreditContract | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
2311,
2528
]
} | 13,010 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | balanceSheetContract | function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
| // Returns _balanceSheetContract | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
2569,
2683
]
} | 13,011 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | setBalanceSheetContract | function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
| // Set _balanceSheetContract | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
2720,
2941
]
} | 13,012 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | bmeMintBatchSize | function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
| // Returns _bmeMintBatchSize | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
2978,
3084
]
} | 13,013 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | setBmeMintBatchSize | function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
| // Set _bmeMintBatchSize | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
3117,
3305
]
} | 13,014 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | bmeClaimBatchSize | function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
| // Returns _bmeClaimBatchSize | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
3343,
3451
]
} | 13,015 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | setBmeClaimBatchSize | function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
| // Set _bmeClaimBatchSize | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
3485,
3677
]
} | 13,016 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | _transfer | function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
| // Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
3873,
4540
]
} | 13,017 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | destroy | function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
| // Call ERC20._burn(from, value) | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
4581,
4753
]
} | 13,018 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | batchDestroy | function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
| // Run destroy for all entries | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
4792,
5224
]
} | 13,019 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | mint | function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
| // Call ERC20._mint(to, value) | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
5263,
5425
]
} | 13,020 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | batchMint | function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
| // Run mint for all entries | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
5461,
5682
]
} | 13,021 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | bmeMint | function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
| // Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
5811,
6305
]
} | 13,022 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | _claimFor | function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
| // Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
6458,
6906
]
} | 13,023 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | claim | function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
| // Calls _claimFor with for = msg.sender | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
7347,
7542
]
} | 13,024 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | claimFor | function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
| // Calls _claimFor with for as provided | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
7590,
7842
]
} | 13,025 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | PrzToken | contract PrzToken is ERC20Detailed, ERC20Mintable, ERC20Destroyable, ERC20Pausable, Ownable {
// Stores the address of the entry credit contract
address private _entryCreditContract;
// Stores the address of contract with burned tokens (basis for BME minting)
address private _balanceSheetContract;
// Stores the amount of addresses to mint for
uint256 private _bmeClaimBatchSize;
uint256 private _bmeMintBatchSize;
// Stores phase state (default value for bool is false,
// https://solidity.readthedocs.io/en/v0.5.3/control-structures.html#default-value)
// Contract will be initialized in "initPhase", i.e. not in bmePhase
bool private _isInBmePhase;
modifier whenNotInBME() {
require(!_isInBmePhase, "Function may no longer be called once BME starts");
_;
}
modifier whenInBME() {
require(_isInBmePhase, "Function may only be called once BME starts");
_;
}
event EntryCreditContractChanged(
address indexed previousEntryCreditContract,
address indexed newEntryCreditContract
);
event BalanceSheetContractChanged(
address indexed previousBalanceSheetContract,
address indexed newBalanceSheetContract
);
event BmeMintBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event BmeClaimBatchSizeChanged(
uint256 indexed previousSize,
uint256 indexed newSize
);
event PhaseChangedToBME(address account);
/**
* @dev Constructor that initializes the PRZToken contract.
*/
constructor (string memory name, string memory symbol, uint8 decimals)
ERC20Detailed(name, symbol, decimals)
ERC20Mintable()
ERC20Destroyable()
ERC20Pausable()
Ownable()
public
{
_isInBmePhase = false;
pause();
setEntryCreditContract(address(0));
setBalanceSheetContract(address(0));
setBmeMintBatchSize(200);
setBmeClaimBatchSize(200);
}
// Returns _entryCreditContract
function entryCreditContract() public view returns (address) {
return _entryCreditContract;
}
// Set _entryCreditContract
function setEntryCreditContract(address contractAddress) public onlyOwner {
emit EntryCreditContractChanged(_entryCreditContract, contractAddress);
_entryCreditContract = contractAddress;
}
// Returns _balanceSheetContract
function balanceSheetContract() public view returns (address) {
return _balanceSheetContract;
}
// Set _balanceSheetContract
function setBalanceSheetContract(address contractAddress) public onlyOwner {
emit BalanceSheetContractChanged(_balanceSheetContract, contractAddress);
_balanceSheetContract = contractAddress;
}
// Returns _bmeMintBatchSize
function bmeMintBatchSize() public view returns (uint256) {
return _bmeMintBatchSize;
}
// Set _bmeMintBatchSize
function setBmeMintBatchSize(uint256 batchSize) public onlyMinter {
emit BmeMintBatchSizeChanged(_bmeMintBatchSize, batchSize);
_bmeMintBatchSize = batchSize;
}
// Returns _bmeClaimBatchSize
function bmeClaimBatchSize() public view returns (uint256) {
return _bmeClaimBatchSize;
}
// Set _bmeClaimBatchSize
function setBmeClaimBatchSize(uint256 batchSize) public onlyMinter {
emit BmeClaimBatchSizeChanged(_bmeClaimBatchSize, batchSize);
_bmeClaimBatchSize = batchSize;
}
// Overwrites ERC20._transfer.
// If to = _entryCreditContract, sends tokens to the credit contract according to the
// exchange rate in credit contract, destroys tokens locally
function _transfer(address from, address to, uint256 value) internal {
if (to == _entryCreditContract) {
_burn(from, value);
IEntryCreditContract entryCreditContractInstance = IEntryCreditContract(to);
require(entryCreditContractInstance.mint(from, value), "Failed to mint entry credits");
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
} else {
super._transfer(from, to, value);
}
}
// Call ERC20._burn(from, value)
function destroy(address from, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.destroy(from, value);
}
// Run destroy for all entries
function batchDestroy(address[] calldata from, uint256[] calldata values)
external onlyDestroyer whenPaused whenNotInBME
returns (bool)
{
uint fromLength = from.length;
require(fromLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < fromLength; i++) {
_burn(from[i], values[i]);
}
return true;
}
// Call ERC20._mint(to, value)
function mint(address to, uint256 value)
public whenPaused whenNotInBME
returns (bool)
{
return super.mint(to, value);
}
// Run mint for all entries
function batchMint(address[] calldata to, uint256[] calldata values)
external onlyMinter whenPaused whenNotInBME
returns (bool)
{
_batchMint(to, values);
return true;
}
// Uses the balance sheet in _balanceSheetContract as a basis for
// batchMint call for _bmeMintBatchSize addresses
function bmeMint()
public onlyMinter whenInBME whenNotPaused
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
(address[] memory receivers, uint256[] memory amounts) = balanceSheetContractInstance.popMintingInformation(_bmeMintBatchSize);
_batchMint(receivers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
// Uses the balance sheet in _balanceSheetContract to create
// tokens for all addresses in for, limits to _bmeMintBatchSize, emit Transfer
function _claimFor(address[] memory claimers)
private
{
IBalanceSheetContract balanceSheetContractInstance = IBalanceSheetContract(_balanceSheetContract);
uint256[] memory amounts = balanceSheetContractInstance.popClaimingInformation(claimers);
_batchMint(claimers, amounts);
require(balanceSheetContractInstance.setPeerzTokenSupply(totalSupply()), "Failed to update token supply");
}
function _batchMint(address[] memory to, uint256[] memory values)
private
{
// length should not be computed at each iteration
uint toLength = to.length;
require(toLength == values.length, "Input arrays must have the same length");
for (uint256 i = 0; i < toLength; i++) {
_mint(to[i], values[i]);
}
}
// Calls _claimFor with for = msg.sender
function claim()
public whenInBME whenNotPaused
{
address[] memory claimers = new address[](1);
claimers[0] = msg.sender;
_claimFor(claimers);
}
// Calls _claimFor with for as provided
function claimFor(address[] calldata claimers)
external whenInBME whenNotPaused
{
require(claimers.length <= _bmeClaimBatchSize, "Input array must be shorter than bme claim batch size.");
_claimFor(claimers);
}
// Change possible when in initPhase
function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
} | changePhaseToBME | function changePhaseToBME()
public onlyOwner whenNotPaused whenNotInBME
{
_isInBmePhase = true;
emit PhaseChangedToBME(msg.sender);
}
| // Change possible when in initPhase | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
7887,
8062
]
} | 13,026 |
|||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | IBalanceSheetContract | interface IBalanceSheetContract {
function setPeerzTokenSupply(uint256 przTotalSupply) external returns (bool);
// NOTE the returned arrays need to have exactly the same length
function popMintingInformation(uint256 bmeMintBatchSize) external returns (address[] memory, uint256[] memory);
// NOTE the returned array needs to have exactly the same length as the claimers array
function popClaimingInformation(address[] calldata claimers) external returns (uint256[] memory);
} | // NOTE the following interface imposes the minimum technically feasible
// NOTE constraints on information that is to be exchanged between the
// NOTE Peerz token contract and the balance sheet contract
// NOTE in other words, in our opinion this interface is the one with the
// NOTE highest probability of allowing for an implementation of the required
// NOTE functionality in the balance sheet contract
// NOTE an alternative approach to having popMintingInformation return two
// NOTE arrays would be to have it return a single array that contains only
// NOTE the receiving addresses for minting and using popClaimingInformation
// NOTE to actually mint the tokens; this approach requires bmeMint to make
// NOTE two external calls instead of a single one; and it imposes more
// NOTE structure on the future implementation of the balance sheet contract
// NOTE since its side of the BME mint functionality would have to be
// NOTE implemented using two separate functions whereas it might also on its
// NOTE side be more efficient to use a single function | LineComment | popMintingInformation | function popMintingInformation(uint256 bmeMintBatchSize) external returns (address[] memory, uint256[] memory);
| // NOTE the returned arrays need to have exactly the same length | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
192,
308
]
} | 13,027 |
|
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | IBalanceSheetContract | interface IBalanceSheetContract {
function setPeerzTokenSupply(uint256 przTotalSupply) external returns (bool);
// NOTE the returned arrays need to have exactly the same length
function popMintingInformation(uint256 bmeMintBatchSize) external returns (address[] memory, uint256[] memory);
// NOTE the returned array needs to have exactly the same length as the claimers array
function popClaimingInformation(address[] calldata claimers) external returns (uint256[] memory);
} | // NOTE the following interface imposes the minimum technically feasible
// NOTE constraints on information that is to be exchanged between the
// NOTE Peerz token contract and the balance sheet contract
// NOTE in other words, in our opinion this interface is the one with the
// NOTE highest probability of allowing for an implementation of the required
// NOTE functionality in the balance sheet contract
// NOTE an alternative approach to having popMintingInformation return two
// NOTE arrays would be to have it return a single array that contains only
// NOTE the receiving addresses for minting and using popClaimingInformation
// NOTE to actually mint the tokens; this approach requires bmeMint to make
// NOTE two external calls instead of a single one; and it imposes more
// NOTE structure on the future implementation of the balance sheet contract
// NOTE since its side of the BME mint functionality would have to be
// NOTE implemented using two separate functions whereas it might also on its
// NOTE side be more efficient to use a single function | LineComment | popClaimingInformation | function popClaimingInformation(address[] calldata claimers) external returns (uint256[] memory);
| // NOTE the returned array needs to have exactly the same length as the claimers array | LineComment | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
403,
505
]
} | 13,028 |
|
UBIQCOIN | UBIQCOIN.sol | 0xb12a5054c2bb31300b27735241c1fd0f22201ef3 | Solidity | UBIQCOIN | contract UBIQCOIN {
struct Event {
address event_address;
uint8 max_member;
uint8 member_count;
}
//Basic Token Info
uint256 public constant totalSupply=1000000000000000000000000000;
string public constant name = "UBIQCOIN";
string public constant symbol = "UBIQTOKEN";
string public constant description = "An smart city solution";
uint32 public constant decimals = 18;
//Event related variables
Event[8] public Events;
address public coin_address;
//Contract deployer address from constructor()
address public owner;
event Transfer(
address indexed _from,
address indexed _to,
uint256 _value);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value);
//ERC20 and individual mappings
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => mapping(address => bool)) public event_mapping;
mapping(address => bool) public coin_purchased;
//Modifier to allow some functions to be run only by the deployer of the contract
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
//balanceOf[_address]=totalSupply;
balanceOf[msg.sender]=totalSupply;
owner = msg.sender;
}
function transfer(address _to, uint256 _value) public returns (bool success){
require(_value <= balanceOf[msg.sender]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
for (uint x=0;x < 8;x++) {
if (_to == Events[x].event_address) {
if (_value == 1 && Events[x].member_count < Events[x].max_member && event_mapping[Events[x].event_address][msg.sender] == false) {
event_mapping[Events[x].event_address][msg.sender] = true;
Events[x].member_count += 1;
}
else {
balanceOf[_to] -= _value;
balanceOf[msg.sender] += _value;
}
}
}
if (_to == coin_address){
if (_value == 1 && coin_purchased[msg.sender] == false){
coin_purchased[msg.sender] = true;
}
else {
balanceOf[_to] -= _value;
balanceOf[msg.sender] += _value;
}
}
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success){
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
require(_value <= balanceOf[_from]);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
//Event creation only by contract owner (see modifier)
function create_event(uint8 _max_member, address _event_address, uint256 _pos) public onlyOwner {
Events[_pos].event_address = _event_address;
Events[_pos].max_member = _max_member;
Events[_pos].member_count = 0;
}
//Coin address setting only by contract owner (see modifier)
function set_coin_address(address _coin_address) public onlyOwner {
coin_address = _coin_address;
}
} | create_event | function create_event(uint8 _max_member, address _event_address, uint256 _pos) public onlyOwner {
Events[_pos].event_address = _event_address;
Events[_pos].max_member = _max_member;
Events[_pos].member_count = 0;
}
| //Event creation only by contract owner (see modifier) | LineComment | v0.5.8+commit.23d335f2 | None | bzzr://a703f5625332fba5a319d587bd2c3dc8457a4b5a43424ff7aa917e7ecad1f225 | {
"func_code_index": [
3315,
3566
]
} | 13,029 |
||
UBIQCOIN | UBIQCOIN.sol | 0xb12a5054c2bb31300b27735241c1fd0f22201ef3 | Solidity | UBIQCOIN | contract UBIQCOIN {
struct Event {
address event_address;
uint8 max_member;
uint8 member_count;
}
//Basic Token Info
uint256 public constant totalSupply=1000000000000000000000000000;
string public constant name = "UBIQCOIN";
string public constant symbol = "UBIQTOKEN";
string public constant description = "An smart city solution";
uint32 public constant decimals = 18;
//Event related variables
Event[8] public Events;
address public coin_address;
//Contract deployer address from constructor()
address public owner;
event Transfer(
address indexed _from,
address indexed _to,
uint256 _value);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value);
//ERC20 and individual mappings
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => mapping(address => bool)) public event_mapping;
mapping(address => bool) public coin_purchased;
//Modifier to allow some functions to be run only by the deployer of the contract
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
//balanceOf[_address]=totalSupply;
balanceOf[msg.sender]=totalSupply;
owner = msg.sender;
}
function transfer(address _to, uint256 _value) public returns (bool success){
require(_value <= balanceOf[msg.sender]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
for (uint x=0;x < 8;x++) {
if (_to == Events[x].event_address) {
if (_value == 1 && Events[x].member_count < Events[x].max_member && event_mapping[Events[x].event_address][msg.sender] == false) {
event_mapping[Events[x].event_address][msg.sender] = true;
Events[x].member_count += 1;
}
else {
balanceOf[_to] -= _value;
balanceOf[msg.sender] += _value;
}
}
}
if (_to == coin_address){
if (_value == 1 && coin_purchased[msg.sender] == false){
coin_purchased[msg.sender] = true;
}
else {
balanceOf[_to] -= _value;
balanceOf[msg.sender] += _value;
}
}
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success){
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
require(_value <= balanceOf[_from]);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
//Event creation only by contract owner (see modifier)
function create_event(uint8 _max_member, address _event_address, uint256 _pos) public onlyOwner {
Events[_pos].event_address = _event_address;
Events[_pos].max_member = _max_member;
Events[_pos].member_count = 0;
}
//Coin address setting only by contract owner (see modifier)
function set_coin_address(address _coin_address) public onlyOwner {
coin_address = _coin_address;
}
} | set_coin_address | function set_coin_address(address _coin_address) public onlyOwner {
coin_address = _coin_address;
}
| //Coin address setting only by contract owner (see modifier) | LineComment | v0.5.8+commit.23d335f2 | None | bzzr://a703f5625332fba5a319d587bd2c3dc8457a4b5a43424ff7aa917e7ecad1f225 | {
"func_code_index": [
3635,
3753
]
} | 13,030 |
||
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address) external;
| /**
修改OWNER
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3231,
3281
]
} | 13,031 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | setYou | function setYou(ITokenYou) external;
| /**
设置YOU
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3313,
3354
]
} | 13,032 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | setInvite | function setInvite(YouswapInviteV1) external;
| /**
设置邀请关系
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3387,
3437
]
} | 13,033 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | deposit | function deposit(uint256, uint256) external;
| /**
质押
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3469,
3518
]
} | 13,034 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | withdraw | function withdraw(uint256, uint256) external;
| /**
解质押、提取奖励
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3557,
3607
]
} | 13,035 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | poolPledgeAddresss | function poolPledgeAddresss(uint256) external view returns (address[] memory);
| /**
矿池质押地址
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3640,
3723
]
} | 13,036 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | powerScale | function powerScale(uint256, address) external view returns (uint256);
| /**
算力占比
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3754,
3829
]
} | 13,037 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | pendingReward | function pendingReward(uint256, address) external view returns (uint256);
| /**
待领取的奖励
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3862,
3940
]
} | 13,038 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | rewardContribute | function rewardContribute(address, address) external view returns (uint256);
| /**
下级收益贡献
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
3973,
4054
]
} | 13,039 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | selfReward | function selfReward(address) external view returns (uint256);
| /**
个人收益加成
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4087,
4153
]
} | 13,040 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | poolNumbers | function poolNumbers(address) external view returns (uint256[] memory);
| /**
通过lp查询矿池编号
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4190,
4266
]
} | 13,041 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | setOperateOwner | function setOperateOwner(address, bool) external;
| /**
设置运营权限
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4299,
4353
]
} | 13,042 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | addPool | function addPool(string memory, address, uint256, uint256) external returns (bool);
| /**
新建矿池
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4484,
4572
]
} | 13,043 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | setRewardPerBlock | function setRewardPerBlock(uint256, uint256) external;
| /**
修改矿池区块奖励
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4615,
4674
]
} | 13,044 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | setRewardTotal | function setRewardTotal(uint256, uint256) external;
| /**
修改矿池总奖励
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4708,
4764
]
} | 13,045 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | setName | function setName(uint256, string memory) external;
| /**
修改矿池名称
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4797,
4852
]
} | 13,046 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | setMultiple | function setMultiple(uint256, uint256) external;
| /**
修改矿池倍数
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4889,
4942
]
} | 13,047 |
YouswapFactoryV1 | localhost/contract/interface/IYouswapFactoryV1.sol | 0x043659e4db135d2b46b41a611ab67eb4d5979ae6 | Solidity | IYouswapFactoryV1 | interface IYouswapFactoryV1 {
/**
用户挖矿信息
*/
struct RewardInfo {
uint256 receiveReward;//总领取奖励
uint256 inviteReward;//总邀请奖励
uint256 pledgeReward;//总质押奖励
}
/**
质押用户信息
*/
struct UserInfo {
uint256 startBlock;//质押开始块高
uint256 amount;//质押数量
uint256 invitePower;//邀请算力
uint256 pledgePower;//质押算力
uint256 pendingReward;//待领取奖励
uint256 inviteRewardDebt;//邀请负债
uint256 pledgeRewardDebt;//质押负债
}
/**
矿池信息(可视化)
*/
struct PoolViewInfo {
address lp;//LP地址
string name;//名称
uint256 multiple;//奖励倍数
uint256 priority;//排序
}
/**
矿池信息
*/
struct PoolInfo {
uint256 startBlock;//挖矿开始块高
uint256 rewardTotal;//矿池总奖励
uint256 rewardProvide;//矿池已发放奖励
address lp;//lp合约地址
uint256 amount;//质押数量
uint256 lastRewardBlock;//最后发放奖励块高
uint256 rewardPerBlock;//单个区块奖励
uint256 totalPower;//总算力
uint256 endBlock;//挖矿结束块高
uint256 rewardPerShare;//单位算力奖励
}
////////////////////////////////////////////////////////////////////////////////////
/**
自邀请
self:Sender地址
*/
event InviteRegister(address indexed self);
/**
更新矿池信息
action:true(新建矿池),false(更新矿池)
pool:矿池序号
lp:lp合约地址
name:矿池名称
startBlock:矿池开始挖矿块高
rewardTotal:矿池总奖励
rewardPerBlock:区块奖励
multiple:矿池奖励倍数
priority:矿池排序
*/
event UpdatePool(bool action, uint256 pool, address indexed lp, string name, uint256 startBlock, uint256 rewardTotal, uint256 rewardPerBlock, uint256 multiple, uint256 priority);
/**
矿池挖矿结束
pool:矿池序号
lp:lp合约地址
*/
event EndPool(uint256 pool, address indexed lp);
/**
质押
pool:矿池序号
lp:lp合约地址
from:质押转出地址
amount:质押数量
*/
event Stake(uint256 pool, address indexed lp, address indexed from, uint256 amount);
/**
pool:矿池序号
lp:lp合约地址
totalPower:矿池总算力
owner:用户地址
ownerInvitePower:用户邀请算力
ownerPledgePower:用户质押算力
upper1:上1级地址
upper1InvitePower:上1级邀请算力
upper2:上2级地址
upper2InvitePower:上2级邀请算力
*/
event UpdatePower(uint256 pool, address lp, uint256 totalPower, address indexed owner, uint256 ownerInvitePower, uint256 ownerPledgePower, address indexed upper1, uint256 upper1InvitePower, address indexed upper2, uint256 upper2InvitePower);
//算力
/**
解质押
pool:矿池序号
lp:lp合约地址
to:解质押转入地址
amount:解质押数量
*/
event UnStake(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
提取奖励
pool:矿池序号
lp:lp合约地址
to:奖励转入地址
amount:奖励数量
*/
event WithdrawReward(uint256 pool, address indexed lp, address indexed to, uint256 amount);
/**
挖矿
pool:矿池序号
lp:lp合约地址
amount:奖励数量
*/
event Mint(uint256 pool, address indexed lp, uint256 amount);
////////////////////////////////////////////////////////////////////////////////////
/**
修改OWNER
*/
function transferOwnership(address) external;
/**
设置YOU
*/
function setYou(ITokenYou) external;
/**
设置邀请关系
*/
function setInvite(YouswapInviteV1) external;
/**
质押
*/
function deposit(uint256, uint256) external;
/**
解质押、提取奖励
*/
function withdraw(uint256, uint256) external;
/**
矿池质押地址
*/
function poolPledgeAddresss(uint256) external view returns (address[] memory);
/**
算力占比
*/
function powerScale(uint256, address) external view returns (uint256);
/**
待领取的奖励
*/
function pendingReward(uint256, address) external view returns (uint256);
/**
下级收益贡献
*/
function rewardContribute(address, address) external view returns (uint256);
/**
个人收益加成
*/
function selfReward(address) external view returns (uint256);
/**
通过lp查询矿池编号
*/
function poolNumbers(address) external view returns (uint256[] memory);
/**
设置运营权限
*/
function setOperateOwner(address, bool) external;
////////////////////////////////////////////////////////////////////////////////////
/**
新建矿池
*/
function addPool(string memory, address, uint256, uint256) external returns (bool);
/**
修改矿池区块奖励
*/
function setRewardPerBlock(uint256, uint256) external;
/**
修改矿池总奖励
*/
function setRewardTotal(uint256, uint256) external;
/**
修改矿池名称
*/
function setName(uint256, string memory) external;
/**
修改矿池倍数
*/
function setMultiple(uint256, uint256) external;
/**
修改矿池排序
*/
function setPriority(uint256, uint256) external;
////////////////////////////////////////////////////////////////////////////////////
} | /**
挖矿
*/ | NatSpecMultiLine | setPriority | function setPriority(uint256, uint256) external;
| /**
修改矿池排序
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://2e342468e031bb1672c69f3b0dc0caab8df1e9b11f505524c594adcaf427759b | {
"func_code_index": [
4979,
5032
]
} | 13,048 |
Petrichor | Petrichor.sol | 0x2b300eb6be34d131b659e601cd0058a2c8ed0963 | Solidity | Petrichor | contract Petrichor is ERC20, ERC20Snapshot, Ownable {
constructor() ERC20("Petrichor", "IXWP") {
_mint(msg.sender, 359000000 * 10 ** decimals());
}
function snapshot() public onlyOwner {
_snapshot();
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Snapshot)
{
super._beforeTokenTransfer(from, to, amount);
}
} | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Snapshot)
{
super._beforeTokenTransfer(from, to, amount);
}
| // The following functions are overrides required by Solidity. | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://f3c2c98ed0139818a4fe7198a60b7e17ce40f71185bf0c198b55367d01b1f5b0 | {
"func_code_index": [
315,
518
]
} | 13,049 |
||
SMASH | SMASH.sol | 0x4cc0f85a9eb0d41cf5fbbff2e1d96ca79f0de93e | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
} | // t.me/SmashFinance | LineComment | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| /**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://0d3a3f96c2ddd316bc01309de2890e0d425e30bd666643a56ba8cab7eed49f5d | {
"func_code_index": [
98,
288
]
} | 13,050 |
OUNCE | OUNCE.sol | 0x3b83e9c4ad682ee848d9f2859756f127f912a618 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
} | /**
* @title FIRST OUNCE Project
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
| /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://9f77d67ae11cc3dccc802346a530435952e7db925cad93646575db624492b5c1 | {
"func_code_index": [
95,
302
]
} | 13,051 |
|
OUNCE | OUNCE.sol | 0x3b83e9c4ad682ee848d9f2859756f127f912a618 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
} | /**
* @title FIRST OUNCE Project
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://9f77d67ae11cc3dccc802346a530435952e7db925cad93646575db624492b5c1 | {
"func_code_index": [
392,
692
]
} | 13,052 |
|
OUNCE | OUNCE.sol | 0x3b83e9c4ad682ee848d9f2859756f127f912a618 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
} | /**
* @title FIRST OUNCE Project
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://9f77d67ae11cc3dccc802346a530435952e7db925cad93646575db624492b5c1 | {
"func_code_index": [
812,
940
]
} | 13,053 |
|
OUNCE | OUNCE.sol | 0x3b83e9c4ad682ee848d9f2859756f127f912a618 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
} | /**
* @title FIRST OUNCE Project
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://9f77d67ae11cc3dccc802346a530435952e7db925cad93646575db624492b5c1 | {
"func_code_index": [
1010,
1156
]
} | 13,054 |
|
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | updateVerifier | function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
| /// Update verifier's data | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
3588,
4162
]
} | 13,055 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | makeBet | function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
| /// Make a bet | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
4185,
5461
]
} | 13,056 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | addFund | function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
| /// Increase total fund of a bet | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
5502,
6109
]
} | 13,057 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | updateOdds | function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
| /// Update odds of a bet | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
6142,
6805
]
} | 13,058 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | pauseBet | function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
| /// Pause a bet | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
6829,
7207
]
} | 13,059 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | reopenBet | function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
| /// Reopen a bet | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
7232,
7612
]
} | 13,060 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | closeBet | function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
| /// Close a bet and withdraw unused fund | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
7661,
9008
]
} | 13,061 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | takeBet | function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
| /// Take a bet | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
9031,
10834
]
} | 13,062 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | settleBet | function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
| /// Settle a bet by trusted verifier | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
10879,
11581
]
} | 13,063 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | withdraw | function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
| /// Manual withdraw fund from a bet after outcome is set | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
11646,
12395
]
} | 13,064 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | payMaker | function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
| /// Payout to maker | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
12423,
13608
]
} | 13,065 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | payTaker | function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
| /// Payout to taker | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
13636,
15500
]
} | 13,066 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | payVerifier | function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
| /// Payout to verifier | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
15531,
16914
]
} | 13,067 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | getOwner | function getOwner() external view returns(address) {
return owner;
}
| /* External views */ | Comment | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
16943,
17030
]
} | 13,068 |
|||
InterbetCore | InterbetCore.sol | 0x0e0a86c97a07856d68bf3387aeb9430dbab93245 | Solidity | InterbetCore | contract InterbetCore {
/* Global constants */
uint constant oddsDecimals = 2; // Max. decimal places of odds
uint constant feeRateDecimals = 1; // Max. decimal places of fee rate
uint public minMakerBetFund = 100 * 1 finney; // Minimum fund of a maker bet
uint public maxAllowedTakerBetsPerMakerBet = 100; // Limit the number of taker-bets in 1 maker-bet
uint public minAllowedStakeInPercentage = 1; // 100 ÷ maxAllowedTakerBetsPerMakerBet
/* Owner and admins */
address private owner;
mapping(address => bool) private admins;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
modifier onlyAdmin() {
require(admins[msg.sender] == true);
_;
}
function changeMinMakerBetFund(uint weis) external onlyAdmin {
minMakerBetFund = mul(weis, 1 wei);
}
function changeTakerBetConstraints(uint maxCount, uint minPercentage) external onlyAdmin {
maxAllowedTakerBetsPerMakerBet = maxCount;
minAllowedStakeInPercentage = minPercentage;
}
/* Events */
event LogUpdateVerifier(address indexed addr, uint oldFeeRate, uint newFeeRate, uint oldBaseFee, uint newBaseFee);
event LogMakeBet(uint indexed makerBetId, address indexed maker);
event LogAddFund(uint indexed makerBetId, address indexed maker, uint oldTotalFund, uint newTotalFund);
event LogUpdateOdds(uint indexed makerBetId, address indexed maker, uint oldOdds, uint newOdds);
event LogPauseBet(uint indexed makerBetId, address indexed maker);
event LogReopenBet(uint indexed makerBetId, address indexed maker);
event LogCloseBet(uint indexed makerBetId, address indexed maker);
event LogTakeBet(uint indexed makerBetId, address indexed maker, uint indexed takerBetId, address taker);
event LogSettleBet(uint indexed makerBetId, address indexed maker);
event LogWithdraw(uint indexed makerBetId, address indexed maker, address indexed addr);
/* Betting Core */
enum BetStatus {
Open,
Paused,
Closed,
Settled
}
enum BetOutcome {
NotSettled,
MakerWin,
TakerWin,
Draw,
Canceled
}
struct MakerBet {
uint makerBetId;
address maker;
uint odds;
uint totalFund;
Verifier trustedVerifier;
uint expiry;
BetStatus status;
uint reservedFund;
uint takerBetsCount;
uint totalStake;
TakerBet[] takerBets;
BetOutcome outcome;
bool makerFundWithdrawn;
bool trustedVerifierFeeSent;
}
struct TakerBet {
uint takerBetId;
address taker;
uint odds;
uint stake;
bool settled;
}
struct Verifier {
address addr;
uint feeRate;
uint baseFee;
}
uint public makerBetsCount;
mapping(uint => mapping(address => MakerBet)) private makerBets;
mapping(address => Verifier) private verifiers;
constructor() public {
owner = msg.sender;
makerBetsCount = 0;
}
function() external payable {
revert();
}
/// Update verifier's data
function updateVerifier(uint feeRate, uint baseFee) external {
require(feeRate >= 0 && feeRate <= ((10 ** feeRateDecimals) * 100));
require(baseFee >= 0 && baseFee <= 100000000 * 1 ether);
Verifier storage verifier = verifiers[msg.sender];
uint oldFeeRate = verifier.feeRate;
uint oldBaseFee = verifier.baseFee;
verifier.addr = msg.sender;
verifier.feeRate = feeRate;
verifier.baseFee = baseFee;
emit LogUpdateVerifier(msg.sender, oldFeeRate, feeRate, oldBaseFee, baseFee);
}
/// Make a bet
function makeBet(uint makerBetId, uint odds, address trustedVerifier, uint trustedVerifierFeeRate, uint trustedVerifierBaseFee, uint expiry) external payable {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
require(expiry > now);
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId == 0);
Verifier memory verifier = verifiers[trustedVerifier];
require(verifier.addr != address(0x0));
require(trustedVerifierFeeRate == verifier.feeRate);
require(trustedVerifierBaseFee == verifier.baseFee);
uint fund = sub(msg.value, trustedVerifierBaseFee);
require(fund >= minMakerBetFund);
makerBet.makerBetId = makerBetId;
makerBet.maker = msg.sender;
makerBet.odds = odds;
makerBet.totalFund = fund;
makerBet.trustedVerifier = Verifier(verifier.addr, verifier.feeRate, verifier.baseFee);
makerBet.expiry = expiry;
makerBet.status = BetStatus.Open;
makerBet.reservedFund = 0;
makerBet.takerBetsCount = 0;
makerBet.totalStake = 0;
makerBetsCount++;
emit LogMakeBet(makerBetId, msg.sender);
}
/// Increase total fund of a bet
function addFund(uint makerBetId) external payable {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(msg.value > 0);
uint oldTotalFund = makerBet.totalFund;
makerBet.totalFund = add(makerBet.totalFund, msg.value);
emit LogAddFund(makerBetId, msg.sender, oldTotalFund, makerBet.totalFund);
}
/// Update odds of a bet
function updateOdds(uint makerBetId, uint odds) external {
require(odds > (10 ** oddsDecimals) && odds < ((10 ** 8) * (10 ** oddsDecimals)));
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
require(odds != makerBet.odds);
uint oldOdds = makerBet.odds;
makerBet.odds = odds;
emit LogUpdateOdds(makerBetId, msg.sender, oldOdds, makerBet.odds);
}
/// Pause a bet
function pauseBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Paused;
emit LogPauseBet(makerBetId, msg.sender);
}
/// Reopen a bet
function reopenBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Open;
emit LogReopenBet(makerBetId, msg.sender);
}
/// Close a bet and withdraw unused fund
function closeBet(uint makerBetId) external {
MakerBet storage makerBet = makerBets[makerBetId][msg.sender];
require(makerBet.makerBetId != 0);
require(makerBet.status == BetStatus.Open || makerBet.status == BetStatus.Paused);
require(msg.sender == makerBet.maker);
makerBet.status = BetStatus.Closed;
// refund unused fund to maker
uint unusedFund = sub(makerBet.totalFund, makerBet.reservedFund);
if (unusedFund > 0) {
makerBet.totalFund = makerBet.reservedFund;
uint refundAmount = unusedFund;
if (makerBet.totalStake == 0) {
refundAmount = add(refundAmount, makerBet.trustedVerifier.baseFee); // Refund base verifier fee too if no taker-bets, because verifier do not need to settle the bet with no takers
makerBet.makerFundWithdrawn = true;
}
if (!makerBet.maker.send(refundAmount)) {
makerBet.totalFund = add(makerBet.totalFund, unusedFund);
makerBet.status = BetStatus.Paused;
makerBet.makerFundWithdrawn = false;
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
} else {
emit LogCloseBet(makerBetId, msg.sender);
}
}
/// Take a bet
function takeBet(uint makerBetId, address maker, uint odds, uint takerBetId) external payable {
require(msg.sender != maker);
require(msg.value > 0);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender != makerBet.trustedVerifier.addr);
require(now < makerBet.expiry);
require(makerBet.status == BetStatus.Open);
require(makerBet.odds == odds);
// Avoid too many taker-bets in one maker-bet
require(makerBet.takerBetsCount < maxAllowedTakerBetsPerMakerBet);
// Avoid too many tiny bets
uint minAllowedStake = mul(mul(makerBet.totalFund, (10 ** oddsDecimals)), minAllowedStakeInPercentage) / sub(odds, (10 ** oddsDecimals)) / 100;
uint maxAvailableStake = mul(sub(makerBet.totalFund, makerBet.reservedFund), (10 ** oddsDecimals)) / sub(odds, (10 ** oddsDecimals));
if (maxAvailableStake >= minAllowedStake) {
require(msg.value >= minAllowedStake);
} else {
require(msg.value >= sub(maxAvailableStake, (maxAvailableStake / 10)) && msg.value <= maxAvailableStake);
}
// If remaining fund is not enough, send the money back.
require(msg.value <= maxAvailableStake);
makerBet.takerBets.length++;
makerBet.takerBets[makerBet.takerBetsCount] = TakerBet(takerBetId, msg.sender, odds, msg.value, false);
makerBet.reservedFund = add(makerBet.reservedFund, mul(msg.value, sub(odds, (10 ** oddsDecimals))) / (10 ** oddsDecimals));
makerBet.totalStake = add(makerBet.totalStake, msg.value);
makerBet.takerBetsCount++;
emit LogTakeBet(makerBetId, maker, takerBetId, msg.sender);
}
/// Settle a bet by trusted verifier
function settleBet(uint makerBetId, address maker, uint outcome) external {
require(outcome == 1 || outcome == 2 || outcome == 3 || outcome == 4);
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(msg.sender == makerBet.trustedVerifier.addr);
require(makerBet.totalStake > 0);
require(makerBet.status != BetStatus.Settled);
BetOutcome betOutcome = BetOutcome(outcome);
makerBet.outcome = betOutcome;
makerBet.status = BetStatus.Settled;
payMaker(makerBet);
payVerifier(makerBet);
emit LogSettleBet(makerBetId, maker);
}
/// Manual withdraw fund from a bet after outcome is set
function withdraw(uint makerBetId, address maker) external {
MakerBet storage makerBet = makerBets[makerBetId][maker];
require(makerBet.makerBetId != 0);
require(makerBet.outcome != BetOutcome.NotSettled);
require(makerBet.status == BetStatus.Settled);
bool fullyWithdrawn = false;
if (msg.sender == maker) {
fullyWithdrawn = payMaker(makerBet);
} else if (msg.sender == makerBet.trustedVerifier.addr) {
fullyWithdrawn = payVerifier(makerBet);
} else {
fullyWithdrawn = payTaker(makerBet, msg.sender);
}
if (fullyWithdrawn) {
emit LogWithdraw(makerBetId, maker, msg.sender);
}
}
/// Payout to maker
function payMaker(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.makerFundWithdrawn) {
makerBet.makerFundWithdrawn = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = sub(add(makerBet.totalFund, makerBet.totalStake), trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
payout = sub(makerBet.totalFund, makerBet.reservedFund);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.totalFund;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.maker.send(payout)) {
makerBet.makerFundWithdrawn = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/// Payout to taker
function payTaker(MakerBet storage makerBet, address taker) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
uint payout = 0;
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
if (makerBet.takerBets[betIndex].taker == taker) {
if (!makerBet.takerBets[betIndex].settled) {
makerBet.takerBets[betIndex].settled = true;
if (makerBet.outcome == BetOutcome.MakerWin) {
continue;
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint netProfit = mul(mul(makerBet.takerBets[betIndex].stake, sub(makerBet.takerBets[betIndex].odds, (10 ** oddsDecimals))), sub(((10 ** feeRateDecimals) * 100), makerBet.trustedVerifier.feeRate)) / (10 ** oddsDecimals) / ((10 ** feeRateDecimals) * 100);
payout = add(payout, add(makerBet.takerBets[betIndex].stake, netProfit));
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = add(payout, makerBet.takerBets[betIndex].stake);
}
}
}
}
if (payout > 0) {
fullyWithdrawn = true;
if (!taker.send(payout)) {
fullyWithdrawn = false;
for (uint betIndex2 = 0; betIndex2 < makerBet.takerBetsCount; betIndex2++) {
if (makerBet.takerBets[betIndex2].taker == taker) {
if (makerBet.takerBets[betIndex2].settled) {
makerBet.takerBets[betIndex2].settled = false;
}
}
}
}
}
return fullyWithdrawn;
}
/// Payout to verifier
function payVerifier(MakerBet storage makerBet) private returns (bool fullyWithdrawn) {
fullyWithdrawn = false;
if (!makerBet.trustedVerifierFeeSent) {
makerBet.trustedVerifierFeeSent = true;
uint payout = 0;
if (makerBet.outcome == BetOutcome.MakerWin) {
uint trustedVerifierFeeMakerWin = mul(makerBet.totalStake, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeMakerWin);
} else if (makerBet.outcome == BetOutcome.TakerWin) {
uint trustedVerifierFeeTakerWin = mul(makerBet.reservedFund, makerBet.trustedVerifier.feeRate) / ((10 ** feeRateDecimals) * 100);
payout = add(makerBet.trustedVerifier.baseFee, trustedVerifierFeeTakerWin);
} else if (makerBet.outcome == BetOutcome.Draw || makerBet.outcome == BetOutcome.Canceled) {
payout = makerBet.trustedVerifier.baseFee;
}
if (payout > 0) {
fullyWithdrawn = true;
if (!makerBet.trustedVerifier.addr.send(payout)) {
makerBet.trustedVerifierFeeSent = false;
fullyWithdrawn = false;
}
}
}
return fullyWithdrawn;
}
/* External views */
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getVerifier(address addr) external view returns(address, uint, uint) {
Verifier memory verifier = verifiers[addr];
return (verifier.addr, verifier.feeRate, verifier.baseFee);
}
function getMakerBetBasicInfo(uint makerBetId, address maker) external view returns(uint, address, address, uint, uint, uint) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.maker, makerBet.trustedVerifier.addr, makerBet.trustedVerifier.feeRate, makerBet.trustedVerifier.baseFee, makerBet.expiry);
}
function getMakerBetDetails(uint makerBetId, address maker) external view returns(uint, BetStatus, uint, uint, uint, uint, uint, BetOutcome, bool, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
return (makerBet.makerBetId, makerBet.status, makerBet.odds, makerBet.totalFund, makerBet.reservedFund, makerBet.takerBetsCount, makerBet.totalStake, makerBet.outcome, makerBet.makerFundWithdrawn, makerBet.trustedVerifierFeeSent);
}
function getTakerBet(uint makerBetId, address maker, uint takerBetId, address taker) external view returns(uint, address, uint, uint, bool) {
MakerBet memory makerBet = makerBets[makerBetId][maker];
for (uint betIndex = 0; betIndex < makerBet.takerBetsCount; betIndex++) {
TakerBet memory takerBet = makerBet.takerBets[betIndex];
if (takerBet.takerBetId == takerBetId && takerBet.taker == taker) {
return (takerBet.takerBetId, takerBet.taker, takerBet.odds, takerBet.stake, takerBet.settled);
}
}
}
/* Math utilities */
function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function sub(uint256 _a, uint256 _b) private pure returns(uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) private pure returns(uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
} | mul | function mul(uint256 _a, uint256 _b) private pure returns(uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
| /* Math utilities */ | Comment | v0.4.24+commit.e67f0147 | bzzr://d64d87c62fc790ad06cbc7c13386d155faedd1bbbb6e1974d8fc763aedb95090 | {
"func_code_index": [
18830,
19044
]
} | 13,069 |
|||
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Proxy | abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
receive () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() virtual internal view returns (address);
/**
* @dev Delegates execution to an implementation contract.
* This is a low level function that doesn't return to its internal call site.
* It will return to the external caller whatever the implementation returns.
* @param implementation Address to delegate.
*/
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
/**
* @dev Function that is run as the first thing in the fallback function.
* Can be redefined in derived contracts to add functionality.
* Redefinitions must call super._willFallback().
*/
function _willFallback() virtual internal {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
if(OpenZeppelinUpgradesAddress.isContract(msg.sender) && msg.data.length == 0 && gasleft() <= 2300) // for receive ETH only from other contract
return;
_willFallback();
_delegate(_implementation());
}
} | /**
* @title Proxy
* @dev Implements delegation of calls to other contracts, with proper
* forwarding of return values and bubbling of failures.
* It defines a fallback function that delegates all calls to the address
* returned by the abstract _implementation() internal function.
*/ | NatSpecMultiLine | /**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
114,
170
]
} | 13,070 |
||
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Proxy | abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
receive () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() virtual internal view returns (address);
/**
* @dev Delegates execution to an implementation contract.
* This is a low level function that doesn't return to its internal call site.
* It will return to the external caller whatever the implementation returns.
* @param implementation Address to delegate.
*/
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
/**
* @dev Function that is run as the first thing in the fallback function.
* Can be redefined in derived contracts to add functionality.
* Redefinitions must call super._willFallback().
*/
function _willFallback() virtual internal {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
if(OpenZeppelinUpgradesAddress.isContract(msg.sender) && msg.data.length == 0 && gasleft() <= 2300) // for receive ETH only from other contract
return;
_willFallback();
_delegate(_implementation());
}
} | /**
* @title Proxy
* @dev Implements delegation of calls to other contracts, with proper
* forwarding of return values and bubbling of failures.
* It defines a fallback function that delegates all calls to the address
* returned by the abstract _implementation() internal function.
*/ | NatSpecMultiLine | _implementation | function _implementation() virtual internal view returns (address);
| /**
* @return The Address of the implementation.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
296,
366
]
} | 13,071 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Proxy | abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
receive () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() virtual internal view returns (address);
/**
* @dev Delegates execution to an implementation contract.
* This is a low level function that doesn't return to its internal call site.
* It will return to the external caller whatever the implementation returns.
* @param implementation Address to delegate.
*/
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
/**
* @dev Function that is run as the first thing in the fallback function.
* Can be redefined in derived contracts to add functionality.
* Redefinitions must call super._willFallback().
*/
function _willFallback() virtual internal {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
if(OpenZeppelinUpgradesAddress.isContract(msg.sender) && msg.data.length == 0 && gasleft() <= 2300) // for receive ETH only from other contract
return;
_willFallback();
_delegate(_implementation());
}
} | /**
* @title Proxy
* @dev Implements delegation of calls to other contracts, with proper
* forwarding of return values and bubbling of failures.
* It defines a fallback function that delegates all calls to the address
* returned by the abstract _implementation() internal function.
*/ | NatSpecMultiLine | _delegate | function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
| /**
* @dev Delegates execution to an implementation contract.
* This is a low level function that doesn't return to its internal call site.
* It will return to the external caller whatever the implementation returns.
* @param implementation Address to delegate.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
657,
1422
]
} | 13,072 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Proxy | abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
receive () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() virtual internal view returns (address);
/**
* @dev Delegates execution to an implementation contract.
* This is a low level function that doesn't return to its internal call site.
* It will return to the external caller whatever the implementation returns.
* @param implementation Address to delegate.
*/
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
/**
* @dev Function that is run as the first thing in the fallback function.
* Can be redefined in derived contracts to add functionality.
* Redefinitions must call super._willFallback().
*/
function _willFallback() virtual internal {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
if(OpenZeppelinUpgradesAddress.isContract(msg.sender) && msg.data.length == 0 && gasleft() <= 2300) // for receive ETH only from other contract
return;
_willFallback();
_delegate(_implementation());
}
} | /**
* @title Proxy
* @dev Implements delegation of calls to other contracts, with proper
* forwarding of return values and bubbling of failures.
* It defines a fallback function that delegates all calls to the address
* returned by the abstract _implementation() internal function.
*/ | NatSpecMultiLine | _willFallback | function _willFallback() virtual internal {
}
| /**
* @dev Function that is run as the first thing in the fallback function.
* Can be redefined in derived contracts to add functionality.
* Redefinitions must call super._willFallback().
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1635,
1694
]
} | 13,073 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Proxy | abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
receive () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() virtual internal view returns (address);
/**
* @dev Delegates execution to an implementation contract.
* This is a low level function that doesn't return to its internal call site.
* It will return to the external caller whatever the implementation returns.
* @param implementation Address to delegate.
*/
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
/**
* @dev Function that is run as the first thing in the fallback function.
* Can be redefined in derived contracts to add functionality.
* Redefinitions must call super._willFallback().
*/
function _willFallback() virtual internal {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
if(OpenZeppelinUpgradesAddress.isContract(msg.sender) && msg.data.length == 0 && gasleft() <= 2300) // for receive ETH only from other contract
return;
_willFallback();
_delegate(_implementation());
}
} | /**
* @title Proxy
* @dev Implements delegation of calls to other contracts, with proper
* forwarding of return values and bubbling of failures.
* It defines a fallback function that delegates all calls to the address
* returned by the abstract _implementation() internal function.
*/ | NatSpecMultiLine | _fallback | function _fallback() internal {
if(OpenZeppelinUpgradesAddress.isContract(msg.sender) && msg.data.length == 0 && gasleft() <= 2300) // for receive ETH only from other contract
return;
_willFallback();
_delegate(_implementation());
}
| /**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1792,
2062
]
} | 13,074 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseUpgradeabilityProxy | abstract contract BaseUpgradeabilityProxy is Proxy {
/**
* @dev Emitted when the implementation is upgraded.
* @param implementation Address of the new implementation.
*/
event Upgraded(address indexed implementation);
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Returns the current implementation.
* @return impl Address of the current implementation
*/
function _implementation() override internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
/**
* @dev Upgrades the proxy to a new implementation.
* @param newImplementation Address of the new implementation.
*/
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
/**
* @dev Sets the implementation address of the proxy.
* @param newImplementation Address of the new implementation.
*/
function _setImplementation(address newImplementation) internal {
require(OpenZeppelinUpgradesAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
} | /**
* @title BaseUpgradeabilityProxy
* @dev This contract implements a proxy that allows to change the
* implementation address to which it will delegate.
* Such a change is called an implementation upgrade.
*/ | NatSpecMultiLine | _implementation | function _implementation() override internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
| /**
* @dev Returns the current implementation.
* @return impl Address of the current implementation
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
693,
866
]
} | 13,075 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseUpgradeabilityProxy | abstract contract BaseUpgradeabilityProxy is Proxy {
/**
* @dev Emitted when the implementation is upgraded.
* @param implementation Address of the new implementation.
*/
event Upgraded(address indexed implementation);
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Returns the current implementation.
* @return impl Address of the current implementation
*/
function _implementation() override internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
/**
* @dev Upgrades the proxy to a new implementation.
* @param newImplementation Address of the new implementation.
*/
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
/**
* @dev Sets the implementation address of the proxy.
* @param newImplementation Address of the new implementation.
*/
function _setImplementation(address newImplementation) internal {
require(OpenZeppelinUpgradesAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
} | /**
* @title BaseUpgradeabilityProxy
* @dev This contract implements a proxy that allows to change the
* implementation address to which it will delegate.
* Such a change is called an implementation upgrade.
*/ | NatSpecMultiLine | _upgradeTo | function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
| /**
* @dev Upgrades the proxy to a new implementation.
* @param newImplementation Address of the new implementation.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1004,
1152
]
} | 13,076 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseUpgradeabilityProxy | abstract contract BaseUpgradeabilityProxy is Proxy {
/**
* @dev Emitted when the implementation is upgraded.
* @param implementation Address of the new implementation.
*/
event Upgraded(address indexed implementation);
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Returns the current implementation.
* @return impl Address of the current implementation
*/
function _implementation() override internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
/**
* @dev Upgrades the proxy to a new implementation.
* @param newImplementation Address of the new implementation.
*/
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
/**
* @dev Sets the implementation address of the proxy.
* @param newImplementation Address of the new implementation.
*/
function _setImplementation(address newImplementation) internal {
require(OpenZeppelinUpgradesAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
} | /**
* @title BaseUpgradeabilityProxy
* @dev This contract implements a proxy that allows to change the
* implementation address to which it will delegate.
* Such a change is called an implementation upgrade.
*/ | NatSpecMultiLine | _setImplementation | function _setImplementation(address newImplementation) internal {
require(OpenZeppelinUpgradesAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
| /**
* @dev Sets the implementation address of the proxy.
* @param newImplementation Address of the new implementation.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1292,
1608
]
} | 13,077 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseAdminUpgradeabilityProxy | contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Emitted when the administration has been transferred.
* @param previousAdmin Address of the previous admin.
* @param newAdmin Address of the new admin.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.
* If it is, it will run the function. Otherwise, it will delegate the call
* to the implementation.
*/
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
/**
* @return The address of the proxy admin.
*/
function admin() external ifAdmin returns (address) {
return _admin();
}
/**
* @return The address of the implementation.
*/
function implementation() external ifAdmin returns (address) {
return _implementation();
}
/**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
/**
* @return adm The admin slot.
*/
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
/**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
/**
* @dev Only fall back when the sender is not the admin.
*/
function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
} | /**
* @title BaseAdminUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with an authorization
* mechanism for administrative tasks.
* All external functions in this contract must be guarded by the
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
* feature proposal that would enable this to be done automatically.
*/ | NatSpecMultiLine | admin | function admin() external ifAdmin returns (address) {
return _admin();
}
| /**
* @return The address of the proxy admin.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
989,
1072
]
} | 13,078 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseAdminUpgradeabilityProxy | contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Emitted when the administration has been transferred.
* @param previousAdmin Address of the previous admin.
* @param newAdmin Address of the new admin.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.
* If it is, it will run the function. Otherwise, it will delegate the call
* to the implementation.
*/
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
/**
* @return The address of the proxy admin.
*/
function admin() external ifAdmin returns (address) {
return _admin();
}
/**
* @return The address of the implementation.
*/
function implementation() external ifAdmin returns (address) {
return _implementation();
}
/**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
/**
* @return adm The admin slot.
*/
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
/**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
/**
* @dev Only fall back when the sender is not the admin.
*/
function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
} | /**
* @title BaseAdminUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with an authorization
* mechanism for administrative tasks.
* All external functions in this contract must be guarded by the
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
* feature proposal that would enable this to be done automatically.
*/ | NatSpecMultiLine | implementation | function implementation() external ifAdmin returns (address) {
return _implementation();
}
| /**
* @return The address of the implementation.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1138,
1239
]
} | 13,079 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseAdminUpgradeabilityProxy | contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Emitted when the administration has been transferred.
* @param previousAdmin Address of the previous admin.
* @param newAdmin Address of the new admin.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.
* If it is, it will run the function. Otherwise, it will delegate the call
* to the implementation.
*/
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
/**
* @return The address of the proxy admin.
*/
function admin() external ifAdmin returns (address) {
return _admin();
}
/**
* @return The address of the implementation.
*/
function implementation() external ifAdmin returns (address) {
return _implementation();
}
/**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
/**
* @return adm The admin slot.
*/
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
/**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
/**
* @dev Only fall back when the sender is not the admin.
*/
function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
} | /**
* @title BaseAdminUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with an authorization
* mechanism for administrative tasks.
* All external functions in this contract must be guarded by the
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
* feature proposal that would enable this to be done automatically.
*/ | NatSpecMultiLine | changeAdmin | function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
| /**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1419,
1650
]
} | 13,080 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseAdminUpgradeabilityProxy | contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Emitted when the administration has been transferred.
* @param previousAdmin Address of the previous admin.
* @param newAdmin Address of the new admin.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.
* If it is, it will run the function. Otherwise, it will delegate the call
* to the implementation.
*/
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
/**
* @return The address of the proxy admin.
*/
function admin() external ifAdmin returns (address) {
return _admin();
}
/**
* @return The address of the implementation.
*/
function implementation() external ifAdmin returns (address) {
return _implementation();
}
/**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
/**
* @return adm The admin slot.
*/
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
/**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
/**
* @dev Only fall back when the sender is not the admin.
*/
function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
} | /**
* @title BaseAdminUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with an authorization
* mechanism for administrative tasks.
* All external functions in this contract must be guarded by the
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
* feature proposal that would enable this to be done automatically.
*/ | NatSpecMultiLine | upgradeTo | function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
| /**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1838,
1946
]
} | 13,081 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseAdminUpgradeabilityProxy | contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Emitted when the administration has been transferred.
* @param previousAdmin Address of the previous admin.
* @param newAdmin Address of the new admin.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.
* If it is, it will run the function. Otherwise, it will delegate the call
* to the implementation.
*/
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
/**
* @return The address of the proxy admin.
*/
function admin() external ifAdmin returns (address) {
return _admin();
}
/**
* @return The address of the implementation.
*/
function implementation() external ifAdmin returns (address) {
return _implementation();
}
/**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
/**
* @return adm The admin slot.
*/
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
/**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
/**
* @dev Only fall back when the sender is not the admin.
*/
function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
} | /**
* @title BaseAdminUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with an authorization
* mechanism for administrative tasks.
* All external functions in this contract must be guarded by the
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
* feature proposal that would enable this to be done automatically.
*/ | NatSpecMultiLine | upgradeToAndCall | function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
| /**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
2471,
2699
]
} | 13,082 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseAdminUpgradeabilityProxy | contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Emitted when the administration has been transferred.
* @param previousAdmin Address of the previous admin.
* @param newAdmin Address of the new admin.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.
* If it is, it will run the function. Otherwise, it will delegate the call
* to the implementation.
*/
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
/**
* @return The address of the proxy admin.
*/
function admin() external ifAdmin returns (address) {
return _admin();
}
/**
* @return The address of the implementation.
*/
function implementation() external ifAdmin returns (address) {
return _implementation();
}
/**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
/**
* @return adm The admin slot.
*/
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
/**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
/**
* @dev Only fall back when the sender is not the admin.
*/
function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
} | /**
* @title BaseAdminUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with an authorization
* mechanism for administrative tasks.
* All external functions in this contract must be guarded by the
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
* feature proposal that would enable this to be done automatically.
*/ | NatSpecMultiLine | _admin | function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
| /**
* @return adm The admin slot.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
2750,
2894
]
} | 13,083 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseAdminUpgradeabilityProxy | contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Emitted when the administration has been transferred.
* @param previousAdmin Address of the previous admin.
* @param newAdmin Address of the new admin.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.
* If it is, it will run the function. Otherwise, it will delegate the call
* to the implementation.
*/
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
/**
* @return The address of the proxy admin.
*/
function admin() external ifAdmin returns (address) {
return _admin();
}
/**
* @return The address of the implementation.
*/
function implementation() external ifAdmin returns (address) {
return _implementation();
}
/**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
/**
* @return adm The admin slot.
*/
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
/**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
/**
* @dev Only fall back when the sender is not the admin.
*/
function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
} | /**
* @title BaseAdminUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with an authorization
* mechanism for administrative tasks.
* All external functions in this contract must be guarded by the
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
* feature proposal that would enable this to be done automatically.
*/ | NatSpecMultiLine | _setAdmin | function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
| /**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
3013,
3155
]
} | 13,084 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | BaseAdminUpgradeabilityProxy | contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Emitted when the administration has been transferred.
* @param previousAdmin Address of the previous admin.
* @param newAdmin Address of the new admin.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.
* If it is, it will run the function. Otherwise, it will delegate the call
* to the implementation.
*/
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
/**
* @return The address of the proxy admin.
*/
function admin() external ifAdmin returns (address) {
return _admin();
}
/**
* @return The address of the implementation.
*/
function implementation() external ifAdmin returns (address) {
return _implementation();
}
/**
* @dev Changes the admin of the proxy.
* Only the current admin can call this function.
* @param newAdmin Address to transfer proxy administration to.
*/
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
/**
* @return adm The admin slot.
*/
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
/**
* @dev Sets the address of the proxy admin.
* @param newAdmin Address of the new proxy admin.
*/
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
/**
* @dev Only fall back when the sender is not the admin.
*/
function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
} | /**
* @title BaseAdminUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with an authorization
* mechanism for administrative tasks.
* All external functions in this contract must be guarded by the
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
* feature proposal that would enable this to be done automatically.
*/ | NatSpecMultiLine | _willFallback | function _willFallback() virtual override internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
//super._willFallback();
}
| /**
* @dev Only fall back when the sender is not the admin.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
3232,
3414
]
} | 13,085 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | InitializableUpgradeabilityProxy | abstract contract InitializableUpgradeabilityProxy is BaseUpgradeabilityProxy {
/**
* @dev Contract initializer.
* @param _logic Address of the initial implementation.
* @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
*/
function initialize(address _logic, bytes memory _data) public payable {
require(_implementation() == address(0));
assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1));
_setImplementation(_logic);
if(_data.length > 0) {
(bool success,) = _logic.delegatecall(_data);
require(success);
}
}
} | /**
* @title InitializableUpgradeabilityProxy
* @dev Extends BaseUpgradeabilityProxy with an initializer for initializing
* implementation and init data.
*/ | NatSpecMultiLine | initialize | function initialize(address _logic, bytes memory _data) public payable {
require(_implementation() == address(0));
assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1));
_setImplementation(_logic);
if(_data.length > 0) {
(bool success,) = _logic.delegatecall(_data);
require(success);
}
}
| /**
* @dev Contract initializer.
* @param _logic Address of the initial implementation.
* @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
611,
987
]
} | 13,086 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | InitializableAdminUpgradeabilityProxy | contract InitializableAdminUpgradeabilityProxy is BaseAdminUpgradeabilityProxy, InitializableUpgradeabilityProxy {
/**
* Contract initializer.
* @param _logic address of the initial implementation.
* @param _admin Address of the proxy administrator.
* @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
*/
function initialize(address _admin, address _logic, bytes memory _data) public payable {
require(_implementation() == address(0));
InitializableUpgradeabilityProxy.initialize(_logic, _data);
assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1));
_setAdmin(_admin);
}
function _willFallback() override(Proxy, BaseAdminUpgradeabilityProxy) internal {
super._willFallback();
}
} | /**
* @title InitializableAdminUpgradeabilityProxy
* @dev Extends from BaseAdminUpgradeabilityProxy with an initializer for
* initializing the implementation, admin, and init data.
*/ | NatSpecMultiLine | initialize | function initialize(address _admin, address _logic, bytes memory _data) public payable {
require(_implementation() == address(0));
InitializableUpgradeabilityProxy.initialize(_logic, _data);
assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1));
_setAdmin(_admin);
}
| /**
* Contract initializer.
* @param _logic address of the initial implementation.
* @param _admin Address of the proxy administrator.
* @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
697,
1012
]
} | 13,087 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | ProductProxy | contract ProductProxy is Proxy {
/**
* @dev Storage slot with the address of the ProxyFactory.
* This is the keccak-256 hash of "eip1967.proxy.factory" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant FACTORY_SLOT = 0x7a45a402e4cb6e08ebc196f20f66d5d30e67285a2a8aa80503fa409e727a4af1;
bytes32 internal constant NAME_SLOT = 0x4cd9b827ca535ceb0880425d70eff88561ecdf04dc32fcf7ff3b15c587f8a870; // bytes32(uint256(keccak256('eip1967.proxy.name')) - 1)
function _name() virtual internal view returns (bytes32 name_) {
bytes32 slot = NAME_SLOT;
assembly { name_ := sload(slot) }
}
function _setName(bytes32 name_) internal {
bytes32 slot = NAME_SLOT;
assembly { sstore(slot, name_) }
}
/**
* @dev Sets the factory address of the ProductProxy.
* @param newFactory Address of the new factory.
*/
function _setFactory(address newFactory) internal {
require(OpenZeppelinUpgradesAddress.isContract(newFactory), "Cannot set a factory to a non-contract address");
bytes32 slot = FACTORY_SLOT;
assembly {
sstore(slot, newFactory)
}
}
/**
* @dev Returns the factory.
* @return factory_ Address of the factory.
*/
function _factory() internal view returns (address factory_) {
bytes32 slot = FACTORY_SLOT;
assembly {
factory_ := sload(slot)
}
}
/**
* @dev Returns the current implementation.
* @return Address of the current implementation
*/
function _implementation() virtual override internal view returns (address) {
address factory_ = _factory();
if(OpenZeppelinUpgradesAddress.isContract(factory_))
return IProxyFactory(factory_).productImplementations(_name());
else
return address(0);
}
} | /**
* @title ProductProxy
* @dev This contract implements a proxy that
* it is deploied by ProxyFactory,
* and it's implementation is stored in factory.
*/ | NatSpecMultiLine | _name | function _name() virtual internal view returns (bytes32 name_) {
bytes32 slot = NAME_SLOT;
assembly { name_ := sload(slot) }
}
| // bytes32(uint256(keccak256('eip1967.proxy.name')) - 1) | LineComment | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
525,
669
]
} | 13,088 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | ProductProxy | contract ProductProxy is Proxy {
/**
* @dev Storage slot with the address of the ProxyFactory.
* This is the keccak-256 hash of "eip1967.proxy.factory" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant FACTORY_SLOT = 0x7a45a402e4cb6e08ebc196f20f66d5d30e67285a2a8aa80503fa409e727a4af1;
bytes32 internal constant NAME_SLOT = 0x4cd9b827ca535ceb0880425d70eff88561ecdf04dc32fcf7ff3b15c587f8a870; // bytes32(uint256(keccak256('eip1967.proxy.name')) - 1)
function _name() virtual internal view returns (bytes32 name_) {
bytes32 slot = NAME_SLOT;
assembly { name_ := sload(slot) }
}
function _setName(bytes32 name_) internal {
bytes32 slot = NAME_SLOT;
assembly { sstore(slot, name_) }
}
/**
* @dev Sets the factory address of the ProductProxy.
* @param newFactory Address of the new factory.
*/
function _setFactory(address newFactory) internal {
require(OpenZeppelinUpgradesAddress.isContract(newFactory), "Cannot set a factory to a non-contract address");
bytes32 slot = FACTORY_SLOT;
assembly {
sstore(slot, newFactory)
}
}
/**
* @dev Returns the factory.
* @return factory_ Address of the factory.
*/
function _factory() internal view returns (address factory_) {
bytes32 slot = FACTORY_SLOT;
assembly {
factory_ := sload(slot)
}
}
/**
* @dev Returns the current implementation.
* @return Address of the current implementation
*/
function _implementation() virtual override internal view returns (address) {
address factory_ = _factory();
if(OpenZeppelinUpgradesAddress.isContract(factory_))
return IProxyFactory(factory_).productImplementations(_name());
else
return address(0);
}
} | /**
* @title ProductProxy
* @dev This contract implements a proxy that
* it is deploied by ProxyFactory,
* and it's implementation is stored in factory.
*/ | NatSpecMultiLine | _setFactory | function _setFactory(address newFactory) internal {
require(OpenZeppelinUpgradesAddress.isContract(newFactory), "Cannot set a factory to a non-contract address");
bytes32 slot = FACTORY_SLOT;
assembly {
sstore(slot, newFactory)
}
}
| /**
* @dev Sets the factory address of the ProductProxy.
* @param newFactory Address of the new factory.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
922,
1190
]
} | 13,089 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | ProductProxy | contract ProductProxy is Proxy {
/**
* @dev Storage slot with the address of the ProxyFactory.
* This is the keccak-256 hash of "eip1967.proxy.factory" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant FACTORY_SLOT = 0x7a45a402e4cb6e08ebc196f20f66d5d30e67285a2a8aa80503fa409e727a4af1;
bytes32 internal constant NAME_SLOT = 0x4cd9b827ca535ceb0880425d70eff88561ecdf04dc32fcf7ff3b15c587f8a870; // bytes32(uint256(keccak256('eip1967.proxy.name')) - 1)
function _name() virtual internal view returns (bytes32 name_) {
bytes32 slot = NAME_SLOT;
assembly { name_ := sload(slot) }
}
function _setName(bytes32 name_) internal {
bytes32 slot = NAME_SLOT;
assembly { sstore(slot, name_) }
}
/**
* @dev Sets the factory address of the ProductProxy.
* @param newFactory Address of the new factory.
*/
function _setFactory(address newFactory) internal {
require(OpenZeppelinUpgradesAddress.isContract(newFactory), "Cannot set a factory to a non-contract address");
bytes32 slot = FACTORY_SLOT;
assembly {
sstore(slot, newFactory)
}
}
/**
* @dev Returns the factory.
* @return factory_ Address of the factory.
*/
function _factory() internal view returns (address factory_) {
bytes32 slot = FACTORY_SLOT;
assembly {
factory_ := sload(slot)
}
}
/**
* @dev Returns the current implementation.
* @return Address of the current implementation
*/
function _implementation() virtual override internal view returns (address) {
address factory_ = _factory();
if(OpenZeppelinUpgradesAddress.isContract(factory_))
return IProxyFactory(factory_).productImplementations(_name());
else
return address(0);
}
} | /**
* @title ProductProxy
* @dev This contract implements a proxy that
* it is deploied by ProxyFactory,
* and it's implementation is stored in factory.
*/ | NatSpecMultiLine | _factory | function _factory() internal view returns (address factory_) {
bytes32 slot = FACTORY_SLOT;
assembly {
factory_ := sload(slot)
}
}
| /**
* @dev Returns the factory.
* @return factory_ Address of the factory.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1286,
1444
]
} | 13,090 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | ProductProxy | contract ProductProxy is Proxy {
/**
* @dev Storage slot with the address of the ProxyFactory.
* This is the keccak-256 hash of "eip1967.proxy.factory" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant FACTORY_SLOT = 0x7a45a402e4cb6e08ebc196f20f66d5d30e67285a2a8aa80503fa409e727a4af1;
bytes32 internal constant NAME_SLOT = 0x4cd9b827ca535ceb0880425d70eff88561ecdf04dc32fcf7ff3b15c587f8a870; // bytes32(uint256(keccak256('eip1967.proxy.name')) - 1)
function _name() virtual internal view returns (bytes32 name_) {
bytes32 slot = NAME_SLOT;
assembly { name_ := sload(slot) }
}
function _setName(bytes32 name_) internal {
bytes32 slot = NAME_SLOT;
assembly { sstore(slot, name_) }
}
/**
* @dev Sets the factory address of the ProductProxy.
* @param newFactory Address of the new factory.
*/
function _setFactory(address newFactory) internal {
require(OpenZeppelinUpgradesAddress.isContract(newFactory), "Cannot set a factory to a non-contract address");
bytes32 slot = FACTORY_SLOT;
assembly {
sstore(slot, newFactory)
}
}
/**
* @dev Returns the factory.
* @return factory_ Address of the factory.
*/
function _factory() internal view returns (address factory_) {
bytes32 slot = FACTORY_SLOT;
assembly {
factory_ := sload(slot)
}
}
/**
* @dev Returns the current implementation.
* @return Address of the current implementation
*/
function _implementation() virtual override internal view returns (address) {
address factory_ = _factory();
if(OpenZeppelinUpgradesAddress.isContract(factory_))
return IProxyFactory(factory_).productImplementations(_name());
else
return address(0);
}
} | /**
* @title ProductProxy
* @dev This contract implements a proxy that
* it is deploied by ProxyFactory,
* and it's implementation is stored in factory.
*/ | NatSpecMultiLine | _implementation | function _implementation() virtual override internal view returns (address) {
address factory_ = _factory();
if(OpenZeppelinUpgradesAddress.isContract(factory_))
return IProxyFactory(factory_).productImplementations(_name());
else
return address(0);
}
| /**
* @dev Returns the current implementation.
* @return Address of the current implementation
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
1562,
1852
]
} | 13,091 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | InitializableProductProxy | contract InitializableProductProxy is ProductProxy {
/**
* @dev Contract initializer.
* @param factory_ Address of the initial factory.
* @param data_ Data to send as msg.data to the implementation to initialize the proxied contract.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
*/
function __InitializableProductProxy_init(address factory_, bytes32 name_, bytes memory data_) public payable {
require(_factory() == address(0));
assert(FACTORY_SLOT == bytes32(uint256(keccak256('eip1967.proxy.factory')) - 1));
assert(NAME_SLOT == bytes32(uint256(keccak256('eip1967.proxy.name')) - 1));
_setFactory(factory_);
_setName(name_);
if(data_.length > 0) {
(bool success,) = _implementation().delegatecall(data_);
require(success);
}
}
} | /**
* @title InitializableProductProxy
* @dev Extends ProductProxy with an initializer for initializing
* factory and init data.
*/ | NatSpecMultiLine | __InitializableProductProxy_init | function __InitializableProductProxy_init(address factory_, bytes32 name_, bytes memory data_) public payable {
require(_factory() == address(0));
assert(FACTORY_SLOT == bytes32(uint256(keccak256('eip1967.proxy.factory')) - 1));
assert(NAME_SLOT == bytes32(uint256(keccak256('eip1967.proxy.name')) - 1));
_setFactory(factory_);
_setName(name_);
if(data_.length > 0) {
(bool success,) = _implementation().delegatecall(data_);
require(success);
}
}
| /**
* @dev Contract initializer.
* @param factory_ Address of the initial factory.
* @param data_ Data to send as msg.data to the implementation to initialize the proxied contract.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
579,
1085
]
} | 13,092 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Initializable | contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private initializing;
/**
* @dev Modifier to use in the initializer function of a contract.
*/
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
} | /**
* @title Initializable
*
* @dev Helper contract to support initializer functions. To use it, replace
* the constructor with a function that has the `initializer` modifier.
* WARNING: Unlike constructors, initializer functions must be manually
* invoked. This applies both to deploying an Initializable contract, as well
* as extending an Initializable contract via inheritance.
* WARNING: When used with inheritance, manual care must be taken to not invoke
* a parent initializer twice, or ensure that all initializers are idempotent,
* because this is not dealt with automatically as with constructors.
*/ | NatSpecMultiLine | isConstructor | function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
| /// @dev Returns true if and only if the function is running in the constructor | NatSpecSingleLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
782,
1293
]
} | 13,093 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | ContextUpgradeSafe | contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
uint256[50] private __gap;
} | /*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/ | Comment | __Context_init | function __Context_init() internal initializer {
__Context_init_unchained();
}
| // Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance. | LineComment | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
206,
303
]
} | 13,094 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Math | library Math {
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
} | /**
* @dev Standard math utilities missing in the Solidity language.
*/ | NatSpecMultiLine | max | function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
| /**
* @dev Returns the largest of two numbers.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
83,
195
]
} | 13,095 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Math | library Math {
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
} | /**
* @dev Standard math utilities missing in the Solidity language.
*/ | NatSpecMultiLine | min | function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
| /**
* @dev Returns the smallest of two numbers.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
266,
377
]
} | 13,096 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | Math | library Math {
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
} | /**
* @dev Standard math utilities missing in the Solidity language.
*/ | NatSpecMultiLine | average | function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
| /**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
491,
689
]
} | 13,097 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function sub0(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a - b : 0;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
251,
437
]
} | 13,098 |
MappingTokenProxy | MappingTokenProxy.sol | 0x910651f81a605a6ef35d05527d24a72fecef8bf0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function sub0(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a - b : 0;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://5cc96e9a2269a4df00789b15941aefadf02222853a460560e6c61a9a18fbf346 | {
"func_code_index": [
707,
848
]
} | 13,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.