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.