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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
receiveEther
|
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
|
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
4148,
4240
]
}
| 11,000
|
|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
function () payable {
receiveEther();
}
|
/// @notice The fall back function is called whenever ether is sent to this
/// contract
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
4343,
4401
]
}
| 11,001
|
||
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
authorizePayment
|
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
|
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
4985,
6098
]
}
| 11,002
|
|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
collectAuthorizedPayment
|
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
|
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
6336,
7121
]
}
| 11,003
|
|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
delayPayment
|
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
|
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
7383,
7874
]
}
| 11,004
|
|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
cancelPayment
|
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
|
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
8038,
8349
]
}
| 11,005
|
|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
authorizeSpender
|
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
|
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
8595,
8781
]
}
| 11,006
|
|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
setSecurityGuard
|
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
|
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
8917,
9037
]
}
| 11,007
|
|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
setTimelock
|
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
|
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
9302,
9455
]
}
| 11,008
|
|
Vault
|
Vault.sol
|
0x598ab825d607ace3b00d8714c0a141c7ae2e6822
|
Solidity
|
Vault
|
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string name; // What is the purpose of this payment
bytes32 reference; // Reference of the payment.
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal if `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = _securityGuard;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _name Brief description of the payment that is authorized
/// @param _reference External reference of the payment
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(
string _name,
bytes32 _reference,
address _recipient,
uint _amount,
uint _paymentDelay
) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender] ) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.name = _name;
p.reference = _reference;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
|
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
|
NatSpecSingleLine
|
setMaxSecurityGuardDelay
|
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
|
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
|
NatSpecSingleLine
|
v0.4.18+commit.9cf6e910
|
bzzr://68cd6154297c049e19a780d0ef661705ad3182cbc26e6886b7998f84aa4cfa7b
|
{
"func_code_index": [
9716,
9859
]
}
| 11,009
|
|
InariV1
|
@boringcrypto/boring-solidity/contracts/libraries/BoringERC20.sol
|
0x195e8262aa81ba560478ec6ca4da73745547073f
|
Solidity
|
BoringERC20
|
library BoringERC20 {
bytes4 private constant SIG_BALANCE_OF = 0x70a08231; // balanceOf(address)
bytes4 private constant SIG_APPROVE = 0x095ea7b3; // approve(address,uint256)
bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256)
/// @notice Provides a gas-optimized balance check on this contract to avoid a redundant extcodesize check in addition to the returndatasize check.
/// @param token The address of the ERC-20 token.
/// @return amount The token amount.
function safeBalanceOfSelf(IERC20 token) internal view returns (uint256 amount) {
(bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_BALANCE_OF, address(this)));
require(success && data.length >= 32, "BoringERC20: BalanceOf failed");
amount = abi.decode(data, (uint256));
}
/// @notice Provides a safe ERC20.approve version for different ERC-20 implementations.
/// @param token The address of the ERC-20 token.
/// @param to The address of the user to grant spending right.
/// @param amount The token amount to grant spending right over.
function safeApprove(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_APPROVE, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Approve failed");
}
/// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransfer(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
}
/// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param from Transfer tokens from.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed");
}
}
|
/// License-Identifier: MIT
/// @dev Adapted for Inari.
|
NatSpecSingleLine
|
safeBalanceOfSelf
|
function safeBalanceOfSelf(IERC20 token) internal view returns (uint256 amount) {
(bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_BALANCE_OF, address(this)));
require(success && data.length >= 32, "BoringERC20: BalanceOf failed");
amount = abi.decode(data, (uint256));
}
|
/// @notice Provides a gas-optimized balance check on this contract to avoid a redundant extcodesize check in addition to the returndatasize check.
/// @param token The address of the ERC-20 token.
/// @return amount The token amount.
|
NatSpecSingleLine
|
v0.7.6+commit.7338295f
|
GNU GPLv2
|
ipfs://89a5125d850fb87a89b52e2cb580c7d062e507e61b962188e0983cbea998b8cd
|
{
"func_code_index": [
625,
973
]
}
| 11,010
|
InariV1
|
@boringcrypto/boring-solidity/contracts/libraries/BoringERC20.sol
|
0x195e8262aa81ba560478ec6ca4da73745547073f
|
Solidity
|
BoringERC20
|
library BoringERC20 {
bytes4 private constant SIG_BALANCE_OF = 0x70a08231; // balanceOf(address)
bytes4 private constant SIG_APPROVE = 0x095ea7b3; // approve(address,uint256)
bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256)
/// @notice Provides a gas-optimized balance check on this contract to avoid a redundant extcodesize check in addition to the returndatasize check.
/// @param token The address of the ERC-20 token.
/// @return amount The token amount.
function safeBalanceOfSelf(IERC20 token) internal view returns (uint256 amount) {
(bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_BALANCE_OF, address(this)));
require(success && data.length >= 32, "BoringERC20: BalanceOf failed");
amount = abi.decode(data, (uint256));
}
/// @notice Provides a safe ERC20.approve version for different ERC-20 implementations.
/// @param token The address of the ERC-20 token.
/// @param to The address of the user to grant spending right.
/// @param amount The token amount to grant spending right over.
function safeApprove(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_APPROVE, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Approve failed");
}
/// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransfer(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
}
/// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param from Transfer tokens from.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed");
}
}
|
/// License-Identifier: MIT
/// @dev Adapted for Inari.
|
NatSpecSingleLine
|
safeApprove
|
function safeApprove(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_APPROVE, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Approve failed");
}
|
/// @notice Provides a safe ERC20.approve version for different ERC-20 implementations.
/// @param token The address of the ERC-20 token.
/// @param to The address of the user to grant spending right.
/// @param amount The token amount to grant spending right over.
|
NatSpecSingleLine
|
v0.7.6+commit.7338295f
|
GNU GPLv2
|
ipfs://89a5125d850fb87a89b52e2cb580c7d062e507e61b962188e0983cbea998b8cd
|
{
"func_code_index": [
1266,
1610
]
}
| 11,011
|
InariV1
|
@boringcrypto/boring-solidity/contracts/libraries/BoringERC20.sol
|
0x195e8262aa81ba560478ec6ca4da73745547073f
|
Solidity
|
BoringERC20
|
library BoringERC20 {
bytes4 private constant SIG_BALANCE_OF = 0x70a08231; // balanceOf(address)
bytes4 private constant SIG_APPROVE = 0x095ea7b3; // approve(address,uint256)
bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256)
/// @notice Provides a gas-optimized balance check on this contract to avoid a redundant extcodesize check in addition to the returndatasize check.
/// @param token The address of the ERC-20 token.
/// @return amount The token amount.
function safeBalanceOfSelf(IERC20 token) internal view returns (uint256 amount) {
(bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_BALANCE_OF, address(this)));
require(success && data.length >= 32, "BoringERC20: BalanceOf failed");
amount = abi.decode(data, (uint256));
}
/// @notice Provides a safe ERC20.approve version for different ERC-20 implementations.
/// @param token The address of the ERC-20 token.
/// @param to The address of the user to grant spending right.
/// @param amount The token amount to grant spending right over.
function safeApprove(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_APPROVE, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Approve failed");
}
/// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransfer(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
}
/// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param from Transfer tokens from.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed");
}
}
|
/// License-Identifier: MIT
/// @dev Adapted for Inari.
|
NatSpecSingleLine
|
safeTransfer
|
function safeTransfer(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
}
|
/// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param to Transfer tokens to.
/// @param amount The token amount.
|
NatSpecSingleLine
|
v0.7.6+commit.7338295f
|
GNU GPLv2
|
ipfs://89a5125d850fb87a89b52e2cb580c7d062e507e61b962188e0983cbea998b8cd
|
{
"func_code_index": [
1881,
2226
]
}
| 11,012
|
InariV1
|
@boringcrypto/boring-solidity/contracts/libraries/BoringERC20.sol
|
0x195e8262aa81ba560478ec6ca4da73745547073f
|
Solidity
|
BoringERC20
|
library BoringERC20 {
bytes4 private constant SIG_BALANCE_OF = 0x70a08231; // balanceOf(address)
bytes4 private constant SIG_APPROVE = 0x095ea7b3; // approve(address,uint256)
bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256)
/// @notice Provides a gas-optimized balance check on this contract to avoid a redundant extcodesize check in addition to the returndatasize check.
/// @param token The address of the ERC-20 token.
/// @return amount The token amount.
function safeBalanceOfSelf(IERC20 token) internal view returns (uint256 amount) {
(bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_BALANCE_OF, address(this)));
require(success && data.length >= 32, "BoringERC20: BalanceOf failed");
amount = abi.decode(data, (uint256));
}
/// @notice Provides a safe ERC20.approve version for different ERC-20 implementations.
/// @param token The address of the ERC-20 token.
/// @param to The address of the user to grant spending right.
/// @param amount The token amount to grant spending right over.
function safeApprove(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_APPROVE, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Approve failed");
}
/// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransfer(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
}
/// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param from Transfer tokens from.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed");
}
}
|
/// License-Identifier: MIT
/// @dev Adapted for Inari.
|
NatSpecSingleLine
|
safeTransferFrom
|
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed");
}
|
/// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param from Transfer tokens from.
/// @param to Transfer tokens to.
/// @param amount The token amount.
|
NatSpecSingleLine
|
v0.7.6+commit.7338295f
|
GNU GPLv2
|
ipfs://89a5125d850fb87a89b52e2cb580c7d062e507e61b962188e0983cbea998b8cd
|
{
"func_code_index": [
2544,
2931
]
}
| 11,013
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
/**
* @dev Substracts 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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
NatSpecMultiLine
|
mul
|
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
|
/**
* @dev Multiplies two numbers, throws on overflow.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
89,
272
]
}
| 11,014
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
/**
* @dev Substracts 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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
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 c;
}
|
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
356,
629
]
}
| 11,015
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
/**
* @dev Substracts 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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
NatSpecMultiLine
|
sub
|
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
|
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
744,
860
]
}
| 11,016
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
/**
* @dev Substracts 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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
NatSpecMultiLine
|
add
|
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
|
/**
* @dev Adds two numbers, throws on overflow.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
924,
1060
]
}
| 11,017
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
NatSpecMultiLine
|
totalSupply
|
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
|
/**
* @dev total number of tokens in existence
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
199,
287
]
}
| 11,018
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
NatSpecMultiLine
|
transfer
|
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
|
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
445,
836
]
}
| 11,019
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
NatSpecMultiLine
|
balanceOf
|
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
|
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
1042,
1154
]
}
| 11,020
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
BurnableToken
|
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
|
/**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/
|
NatSpecMultiLine
|
burn
|
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
|
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
212,
640
]
}
| 11,021
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken, BurnableToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
transferFrom
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
|
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
416,
868
]
}
| 11,022
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken, BurnableToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
approve
|
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
|
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
1500,
1690
]
}
| 11,023
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken, BurnableToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
allowance
|
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
|
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
2014,
2145
]
}
| 11,024
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken, BurnableToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
increaseApproval
|
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
|
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
2611,
2875
]
}
| 11,025
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken, BurnableToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
decreaseApproval
|
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
|
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
3346,
3756
]
}
| 11,026
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
Ownable
|
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
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
|
Ownable
|
function Ownable() public {
owner = msg.sender;
}
|
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
261,
321
]
}
| 11,027
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
Ownable
|
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
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 {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
|
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
640,
816
]
}
| 11,028
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
MintableToken
|
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
|
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
|
NatSpecMultiLine
|
mint
|
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
|
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
483,
756
]
}
| 11,029
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
MintableToken
|
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
|
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
|
NatSpecMultiLine
|
finishMinting
|
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
|
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
873,
1015
]
}
| 11,030
|
|
BitcoinBlack
|
BitcoinBlack.sol
|
0xf7ae0daa230bf3fb3c0e5e01e7a6e0a142c6cf7e
|
Solidity
|
BitcoinBlack
|
contract BitcoinBlack is StandardToken, MintableToken {
string public constant name = "Bitcoin Black"; // solium-disable-line uppercase
string public constant symbol = "BLACK"; // solium-disable-line uppercase
uint8 public constant decimals = 18; // solium-disable-line uppercase
uint256 public constant INITIAL_SUPPLY = 21000000 * (10 ** uint256(decimals));
/**
* @dev Constructor that gives msg.sender all of existing tokens.
*/
function BitcoinBlack() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
}
|
BitcoinBlack
|
function BitcoinBlack() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
|
/**
* @dev Constructor that gives msg.sender all of existing tokens.
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
bzzr://726505a769ccddcd34067732052463cd120aadcfef4fde678654480d668c90ac
|
{
"func_code_index": [
461,
629
]
}
| 11,031
|
|||
DraculaHoard
|
..\aar-contracts\DraculaHoard.sol
|
0xc14b5ea0b86958e57e69b33322ef59d3f510884a
|
Solidity
|
DraculaHoard
|
contract DraculaHoard is ERC20("DraculaHoard", "BLOOD"), Ownable {
using SafeMath for uint256;
IERC20 public dracula;
uint256 public burnRate = 1;
constructor(IERC20 _dracula) public {
dracula = _dracula;
}
function setBurnRate(uint256 _burnRate) external onlyOwner {
require(_burnRate <= 10, "Invalid burn rate value");
burnRate = _burnRate;
}
/// @notice Return staked amount + rewards
function balance(address account) public view returns (uint256) {
uint256 totalShares = totalSupply();
return (totalShares > 0) ? balanceOf(account).mul(dracula.balanceOf(address(this))).div(totalShares) : 0;
}
function stake(uint256 _amount) external {
uint256 totalDracula = dracula.balanceOf(address(this));
uint256 totalShares = totalSupply();
if (totalShares == 0 || totalDracula == 0) {
_mint(msg.sender, _amount);
}
else {
uint256 what = _amount.mul(totalShares).div(totalDracula);
_mint(msg.sender, what);
}
dracula.transferFrom(msg.sender, address(this), _amount);
}
function unstake(uint256 _share) external {
uint256 totalShares = totalSupply();
uint256 what = _share.mul(dracula.balanceOf(address(this))).div(totalShares);
_burn(msg.sender, _share);
uint256 burnAmount = what.mul(burnRate).div(100);
if (burnAmount > 0) {
DraculaToken(address(dracula)).burn(burnAmount);
}
dracula.transfer(msg.sender, what.sub(burnAmount));
}
}
|
balance
|
function balance(address account) public view returns (uint256) {
uint256 totalShares = totalSupply();
return (totalShares > 0) ? balanceOf(account).mul(dracula.balanceOf(address(this))).div(totalShares) : 0;
}
|
/// @notice Return staked amount + rewards
|
NatSpecSingleLine
|
v0.6.12+commit.27d51765
|
MIT
|
ipfs://fa6a8c66cab676743eeb33220704d1f9c268dedd17e2e58e1601a30304c86608
|
{
"func_code_index": [
462,
700
]
}
| 11,032
|
||
ERC20Vested
|
contracts/math/SignedSafeMath.sol
|
0xcdb9d30a3ba48cdfcb0ecbe19317e6cf783672f1
|
Solidity
|
SignedSafeMath
|
library SignedSafeMath {
/**
* @dev Returns the multiplication of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
return a * b;
}
/**
* @dev Returns the integer division of two signed integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
return a / b;
}
/**
* @dev Returns the subtraction of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
return a - b;
}
/**
* @dev Returns the addition of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
return a + b;
}
}
|
/**
* @title SignedSafeMath
* @dev Signed math operations that revert on error.
*/
|
NatSpecMultiLine
|
mul
|
function mul(int256 a, int256 b) internal pure returns (int256) {
return a * b;
}
|
/**
* @dev Returns the multiplication of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
|
NatSpecMultiLine
|
v0.8.1+commit.df193b15
|
MIT
|
ipfs://ff477603eee65922adc0e88083abef1fcda42c119dc941d4d45d38e1cb8f776f
|
{
"func_code_index": [
275,
375
]
}
| 11,033
|
ERC20Vested
|
contracts/math/SignedSafeMath.sol
|
0xcdb9d30a3ba48cdfcb0ecbe19317e6cf783672f1
|
Solidity
|
SignedSafeMath
|
library SignedSafeMath {
/**
* @dev Returns the multiplication of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
return a * b;
}
/**
* @dev Returns the integer division of two signed integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
return a / b;
}
/**
* @dev Returns the subtraction of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
return a - b;
}
/**
* @dev Returns the addition of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
return a + b;
}
}
|
/**
* @title SignedSafeMath
* @dev Signed math operations that revert on error.
*/
|
NatSpecMultiLine
|
div
|
function div(int256 a, int256 b) internal pure returns (int256) {
return a / b;
}
|
/**
* @dev Returns the integer division of two signed integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
|
NatSpecMultiLine
|
v0.8.1+commit.df193b15
|
MIT
|
ipfs://ff477603eee65922adc0e88083abef1fcda42c119dc941d4d45d38e1cb8f776f
|
{
"func_code_index": [
667,
767
]
}
| 11,034
|
ERC20Vested
|
contracts/math/SignedSafeMath.sol
|
0xcdb9d30a3ba48cdfcb0ecbe19317e6cf783672f1
|
Solidity
|
SignedSafeMath
|
library SignedSafeMath {
/**
* @dev Returns the multiplication of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
return a * b;
}
/**
* @dev Returns the integer division of two signed integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
return a / b;
}
/**
* @dev Returns the subtraction of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
return a - b;
}
/**
* @dev Returns the addition of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
return a + b;
}
}
|
/**
* @title SignedSafeMath
* @dev Signed math operations that revert on error.
*/
|
NatSpecMultiLine
|
sub
|
function sub(int256 a, int256 b) internal pure returns (int256) {
return a - b;
}
|
/**
* @dev Returns the subtraction of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
|
NatSpecMultiLine
|
v0.8.1+commit.df193b15
|
MIT
|
ipfs://ff477603eee65922adc0e88083abef1fcda42c119dc941d4d45d38e1cb8f776f
|
{
"func_code_index": [
1013,
1113
]
}
| 11,035
|
ERC20Vested
|
contracts/math/SignedSafeMath.sol
|
0xcdb9d30a3ba48cdfcb0ecbe19317e6cf783672f1
|
Solidity
|
SignedSafeMath
|
library SignedSafeMath {
/**
* @dev Returns the multiplication of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
return a * b;
}
/**
* @dev Returns the integer division of two signed integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
return a / b;
}
/**
* @dev Returns the subtraction of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
return a - b;
}
/**
* @dev Returns the addition of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
return a + b;
}
}
|
/**
* @title SignedSafeMath
* @dev Signed math operations that revert on error.
*/
|
NatSpecMultiLine
|
add
|
function add(int256 a, int256 b) internal pure returns (int256) {
return a + b;
}
|
/**
* @dev Returns the addition of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
|
NatSpecMultiLine
|
v0.8.1+commit.df193b15
|
MIT
|
ipfs://ff477603eee65922adc0e88083abef1fcda42c119dc941d4d45d38e1cb8f776f
|
{
"func_code_index": [
1353,
1453
]
}
| 11,036
|
UniqGenesis
|
./contracts/utils/ERC721/ERC721Claimable.sol
|
0xd804c52524f1cfad0fae54d2f2b15871337e96b3
|
Solidity
|
ERC721Claimable
|
abstract contract ERC721Claimable is
ContextMixin,
ERC721Enumerable,
NativeMetaTransaction,
Ownable
{
// ----- VARIABLES ----- //
address proxyRegistryAddress;
string internal _token_uri;
address internal _claimingAddress;
string public METADATA_PROVENANCE_HASH;
uint256 public ROYALTY_FEE;
// ----- EVENTS ----- //
event ReceivedRoyalties(
address indexed _royaltyRecipient,
address indexed _buyer,
uint256 indexed _tokenId,
address _tokenPaid,
uint256 _amount
);
// ----- CONSTRUCTOR ----- //
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address _proxyRegistryAddress,
address _claimingContractAddress,
uint256 _royaltyFee
) ERC721(_name, _symbol) {
proxyRegistryAddress = _proxyRegistryAddress;
_token_uri = _uri;
_initializeEIP712(_name);
_claimingAddress = _claimingContractAddress;
ROYALTY_FEE = _royaltyFee;
}
// ----- VIEWS ----- //
function baseTokenURI() public view virtual returns (string memory){
return _token_uri;
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
return
string(
abi.encodePacked(baseTokenURI(), Strings.toString(_tokenId))
);
}
function getClaimerAddress() external view returns (address) {
return _claimingAddress;
}
function royaltyInfo(uint256)
external
view
returns (address receiver, uint256 amount)
{
return (owner(), ROYALTY_FEE);
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
if (address(proxyRegistry.proxies(owner)) == operator) {
return true;
}
return super.isApprovedForAll(owner, operator);
}
function _msgSender() internal view override returns (address sender) {
return ContextMixin.msgSender();
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 index;
for (index = 0; index < tokenCount; index++) {
result[index] = tokenOfOwnerByIndex(_owner, index);
}
return result;
}
}
// ----- PUBLIC METHODS ----- //
function burn(uint256 _tokenId) external {
if (msg.sender != _claimingAddress) {
require(
_isApprovedOrOwner(msg.sender, _tokenId),
"Ownership or approval required"
);
}
_burn(_tokenId);
}
function receivedRoyalties(
address,
address _buyer,
uint256 _tokenId,
address _tokenPaid,
uint256 _amount
) external {
emit ReceivedRoyalties(owner(), _buyer, _tokenId, _tokenPaid, _amount);
}
// ----- OWNERS METHODS ----- //
function editClaimingAdress(address _newAddress) external onlyOwner {
_claimingAddress = _newAddress;
}
function editRoyaltyFee(uint256 _newFee) external onlyOwner{
ROYALTY_FEE = _newFee;
}
function setProvenanceHash(string memory _hash) external onlyOwner {
METADATA_PROVENANCE_HASH = _hash;
}
}
|
baseTokenURI
|
function baseTokenURI() public view virtual returns (string memory){
return _token_uri;
}
|
// ----- VIEWS ----- //
|
LineComment
|
v0.8.6+commit.11564f7e
|
MIT
|
ipfs://5adf4d24848f3e599a1110d0be7c407fa8f355a20311f48c1565b436f59758af
|
{
"func_code_index": [
1076,
1181
]
}
| 11,037
|
||
UniqGenesis
|
./contracts/utils/ERC721/ERC721Claimable.sol
|
0xd804c52524f1cfad0fae54d2f2b15871337e96b3
|
Solidity
|
ERC721Claimable
|
abstract contract ERC721Claimable is
ContextMixin,
ERC721Enumerable,
NativeMetaTransaction,
Ownable
{
// ----- VARIABLES ----- //
address proxyRegistryAddress;
string internal _token_uri;
address internal _claimingAddress;
string public METADATA_PROVENANCE_HASH;
uint256 public ROYALTY_FEE;
// ----- EVENTS ----- //
event ReceivedRoyalties(
address indexed _royaltyRecipient,
address indexed _buyer,
uint256 indexed _tokenId,
address _tokenPaid,
uint256 _amount
);
// ----- CONSTRUCTOR ----- //
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address _proxyRegistryAddress,
address _claimingContractAddress,
uint256 _royaltyFee
) ERC721(_name, _symbol) {
proxyRegistryAddress = _proxyRegistryAddress;
_token_uri = _uri;
_initializeEIP712(_name);
_claimingAddress = _claimingContractAddress;
ROYALTY_FEE = _royaltyFee;
}
// ----- VIEWS ----- //
function baseTokenURI() public view virtual returns (string memory){
return _token_uri;
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
return
string(
abi.encodePacked(baseTokenURI(), Strings.toString(_tokenId))
);
}
function getClaimerAddress() external view returns (address) {
return _claimingAddress;
}
function royaltyInfo(uint256)
external
view
returns (address receiver, uint256 amount)
{
return (owner(), ROYALTY_FEE);
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
if (address(proxyRegistry.proxies(owner)) == operator) {
return true;
}
return super.isApprovedForAll(owner, operator);
}
function _msgSender() internal view override returns (address sender) {
return ContextMixin.msgSender();
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 index;
for (index = 0; index < tokenCount; index++) {
result[index] = tokenOfOwnerByIndex(_owner, index);
}
return result;
}
}
// ----- PUBLIC METHODS ----- //
function burn(uint256 _tokenId) external {
if (msg.sender != _claimingAddress) {
require(
_isApprovedOrOwner(msg.sender, _tokenId),
"Ownership or approval required"
);
}
_burn(_tokenId);
}
function receivedRoyalties(
address,
address _buyer,
uint256 _tokenId,
address _tokenPaid,
uint256 _amount
) external {
emit ReceivedRoyalties(owner(), _buyer, _tokenId, _tokenPaid, _amount);
}
// ----- OWNERS METHODS ----- //
function editClaimingAdress(address _newAddress) external onlyOwner {
_claimingAddress = _newAddress;
}
function editRoyaltyFee(uint256 _newFee) external onlyOwner{
ROYALTY_FEE = _newFee;
}
function setProvenanceHash(string memory _hash) external onlyOwner {
METADATA_PROVENANCE_HASH = _hash;
}
}
|
burn
|
function burn(uint256 _tokenId) external {
if (msg.sender != _claimingAddress) {
require(
_isApprovedOrOwner(msg.sender, _tokenId),
"Ownership or approval required"
);
}
_burn(_tokenId);
}
|
// ----- PUBLIC METHODS ----- //
|
LineComment
|
v0.8.6+commit.11564f7e
|
MIT
|
ipfs://5adf4d24848f3e599a1110d0be7c407fa8f355a20311f48c1565b436f59758af
|
{
"func_code_index": [
2812,
3088
]
}
| 11,038
|
||
UniqGenesis
|
./contracts/utils/ERC721/ERC721Claimable.sol
|
0xd804c52524f1cfad0fae54d2f2b15871337e96b3
|
Solidity
|
ERC721Claimable
|
abstract contract ERC721Claimable is
ContextMixin,
ERC721Enumerable,
NativeMetaTransaction,
Ownable
{
// ----- VARIABLES ----- //
address proxyRegistryAddress;
string internal _token_uri;
address internal _claimingAddress;
string public METADATA_PROVENANCE_HASH;
uint256 public ROYALTY_FEE;
// ----- EVENTS ----- //
event ReceivedRoyalties(
address indexed _royaltyRecipient,
address indexed _buyer,
uint256 indexed _tokenId,
address _tokenPaid,
uint256 _amount
);
// ----- CONSTRUCTOR ----- //
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address _proxyRegistryAddress,
address _claimingContractAddress,
uint256 _royaltyFee
) ERC721(_name, _symbol) {
proxyRegistryAddress = _proxyRegistryAddress;
_token_uri = _uri;
_initializeEIP712(_name);
_claimingAddress = _claimingContractAddress;
ROYALTY_FEE = _royaltyFee;
}
// ----- VIEWS ----- //
function baseTokenURI() public view virtual returns (string memory){
return _token_uri;
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
return
string(
abi.encodePacked(baseTokenURI(), Strings.toString(_tokenId))
);
}
function getClaimerAddress() external view returns (address) {
return _claimingAddress;
}
function royaltyInfo(uint256)
external
view
returns (address receiver, uint256 amount)
{
return (owner(), ROYALTY_FEE);
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
if (address(proxyRegistry.proxies(owner)) == operator) {
return true;
}
return super.isApprovedForAll(owner, operator);
}
function _msgSender() internal view override returns (address sender) {
return ContextMixin.msgSender();
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 index;
for (index = 0; index < tokenCount; index++) {
result[index] = tokenOfOwnerByIndex(_owner, index);
}
return result;
}
}
// ----- PUBLIC METHODS ----- //
function burn(uint256 _tokenId) external {
if (msg.sender != _claimingAddress) {
require(
_isApprovedOrOwner(msg.sender, _tokenId),
"Ownership or approval required"
);
}
_burn(_tokenId);
}
function receivedRoyalties(
address,
address _buyer,
uint256 _tokenId,
address _tokenPaid,
uint256 _amount
) external {
emit ReceivedRoyalties(owner(), _buyer, _tokenId, _tokenPaid, _amount);
}
// ----- OWNERS METHODS ----- //
function editClaimingAdress(address _newAddress) external onlyOwner {
_claimingAddress = _newAddress;
}
function editRoyaltyFee(uint256 _newFee) external onlyOwner{
ROYALTY_FEE = _newFee;
}
function setProvenanceHash(string memory _hash) external onlyOwner {
METADATA_PROVENANCE_HASH = _hash;
}
}
|
editClaimingAdress
|
function editClaimingAdress(address _newAddress) external onlyOwner {
_claimingAddress = _newAddress;
}
|
// ----- OWNERS METHODS ----- //
|
LineComment
|
v0.8.6+commit.11564f7e
|
MIT
|
ipfs://5adf4d24848f3e599a1110d0be7c407fa8f355a20311f48c1565b436f59758af
|
{
"func_code_index": [
3382,
3501
]
}
| 11,039
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
/**
* @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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
NatSpecMultiLine
|
mul
|
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
|
/**
* @dev Multiplies two numbers, throws on overflow.
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
95,
308
]
}
| 11,040
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
/**
* @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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
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 c;
}
|
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
398,
691
]
}
| 11,041
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
/**
* @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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
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.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
811,
939
]
}
| 11,042
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
/**
* @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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
NatSpecMultiLine
|
add
|
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
|
/**
* @dev Adds two numbers, throws on overflow.
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
1009,
1161
]
}
| 11,043
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
NatSpecMultiLine
|
totalSupply
|
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
|
/**
* @dev total number of tokens in existence
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
211,
307
]
}
| 11,044
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
NatSpecMultiLine
|
transfer
|
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
|
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
475,
903
]
}
| 11,045
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
NatSpecMultiLine
|
balanceOf
|
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
|
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
1119,
1239
]
}
| 11,046
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
transferFrom
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
|
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
413,
906
]
}
| 11,047
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
approve
|
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
|
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
1558,
1769
]
}
| 11,048
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
allowance
|
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
|
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
2105,
2258
]
}
| 11,049
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
increaseApproval
|
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
|
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
2515,
2809
]
}
| 11,050
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
TokenVesting
|
contract TokenVesting is Owned {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
address internal ownerShip;
/**
* @dev Creates a vesting contract that vests its balance of any ERC20 token to the
* _beneficiary, gradually in a linear fashion until _start + _duration. By then all
* of the balance will have vested.
* @param _beneficiary address of the beneficiary to whom vested tokens are transferred
* @param _cliff duration in seconds of the cliff in which tokens will begin to vest
* @param _start the time (as Unix time) at which point vesting starts
* @param _duration duration in seconds of the period in which the tokens will vest
* @param _revocable whether the vesting is revocable or not
*/
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _realOwner
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
ownerShip = _realOwner;
}
/**
* @notice Transfers vested tokens to beneficiary.
* @param token ERC20 token which is being vested
*/
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
/**
* @notice Allows the owner to revoke the vesting. Tokens already vested
* remain in the contract, the rest are returned to the owner.
* @param token ERC20 token which is being vested
*/
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
* @param token ERC20 token which is being vested
*/
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
/**
* @dev Calculates the amount that has already vested.
* @param token ERC20 token which is being vested
*/
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
|
/**
* @title TokenVesting
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
* owner.
*/
|
NatSpecMultiLine
|
release
|
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
|
/**
* @notice Transfers vested tokens to beneficiary.
* @param token ERC20 token which is being vested
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
1791,
2093
]
}
| 11,051
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
TokenVesting
|
contract TokenVesting is Owned {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
address internal ownerShip;
/**
* @dev Creates a vesting contract that vests its balance of any ERC20 token to the
* _beneficiary, gradually in a linear fashion until _start + _duration. By then all
* of the balance will have vested.
* @param _beneficiary address of the beneficiary to whom vested tokens are transferred
* @param _cliff duration in seconds of the cliff in which tokens will begin to vest
* @param _start the time (as Unix time) at which point vesting starts
* @param _duration duration in seconds of the period in which the tokens will vest
* @param _revocable whether the vesting is revocable or not
*/
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _realOwner
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
ownerShip = _realOwner;
}
/**
* @notice Transfers vested tokens to beneficiary.
* @param token ERC20 token which is being vested
*/
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
/**
* @notice Allows the owner to revoke the vesting. Tokens already vested
* remain in the contract, the rest are returned to the owner.
* @param token ERC20 token which is being vested
*/
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
* @param token ERC20 token which is being vested
*/
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
/**
* @dev Calculates the amount that has already vested.
* @param token ERC20 token which is being vested
*/
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
|
/**
* @title TokenVesting
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
* owner.
*/
|
NatSpecMultiLine
|
revoke
|
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
|
/**
* @notice Allows the owner to revoke the vesting. Tokens already vested
* remain in the contract, the rest are returned to the owner.
* @param token ERC20 token which is being vested
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
2315,
2714
]
}
| 11,052
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
TokenVesting
|
contract TokenVesting is Owned {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
address internal ownerShip;
/**
* @dev Creates a vesting contract that vests its balance of any ERC20 token to the
* _beneficiary, gradually in a linear fashion until _start + _duration. By then all
* of the balance will have vested.
* @param _beneficiary address of the beneficiary to whom vested tokens are transferred
* @param _cliff duration in seconds of the cliff in which tokens will begin to vest
* @param _start the time (as Unix time) at which point vesting starts
* @param _duration duration in seconds of the period in which the tokens will vest
* @param _revocable whether the vesting is revocable or not
*/
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _realOwner
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
ownerShip = _realOwner;
}
/**
* @notice Transfers vested tokens to beneficiary.
* @param token ERC20 token which is being vested
*/
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
/**
* @notice Allows the owner to revoke the vesting. Tokens already vested
* remain in the contract, the rest are returned to the owner.
* @param token ERC20 token which is being vested
*/
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
* @param token ERC20 token which is being vested
*/
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
/**
* @dev Calculates the amount that has already vested.
* @param token ERC20 token which is being vested
*/
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
|
/**
* @title TokenVesting
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
* owner.
*/
|
NatSpecMultiLine
|
releasableAmount
|
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
|
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
* @param token ERC20 token which is being vested
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
2879,
3024
]
}
| 11,053
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
TokenVesting
|
contract TokenVesting is Owned {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
address internal ownerShip;
/**
* @dev Creates a vesting contract that vests its balance of any ERC20 token to the
* _beneficiary, gradually in a linear fashion until _start + _duration. By then all
* of the balance will have vested.
* @param _beneficiary address of the beneficiary to whom vested tokens are transferred
* @param _cliff duration in seconds of the cliff in which tokens will begin to vest
* @param _start the time (as Unix time) at which point vesting starts
* @param _duration duration in seconds of the period in which the tokens will vest
* @param _revocable whether the vesting is revocable or not
*/
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _realOwner
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
ownerShip = _realOwner;
}
/**
* @notice Transfers vested tokens to beneficiary.
* @param token ERC20 token which is being vested
*/
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
/**
* @notice Allows the owner to revoke the vesting. Tokens already vested
* remain in the contract, the rest are returned to the owner.
* @param token ERC20 token which is being vested
*/
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
* @param token ERC20 token which is being vested
*/
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
/**
* @dev Calculates the amount that has already vested.
* @param token ERC20 token which is being vested
*/
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
|
/**
* @title TokenVesting
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
* owner.
*/
|
NatSpecMultiLine
|
vestedAmount
|
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
|
/**
* @dev Calculates the amount that has already vested.
* @param token ERC20 token which is being vested
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
3160,
3657
]
}
| 11,054
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
TokenVault
|
contract TokenVault {
using SafeERC20 for ERC20;
// ERC20 token contract being held
ERC20 public token;
constructor(ERC20 _token) public {
token = _token;
}
/**
* @notice Allow the token itself to send tokens
* using transferFrom().
*/
function fillUpAllowance() public {
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.approve(token, amount);
}
}
|
/**
* @title TokenVault
* @dev TokenVault is a token holder contract that will allow a
* beneficiary to spend the tokens from some function of a specified ERC20 token
*/
|
NatSpecMultiLine
|
fillUpAllowance
|
function fillUpAllowance() public {
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.approve(token, amount);
}
|
/**
* @notice Allow the token itself to send tokens
* using transferFrom().
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
300,
467
]
}
| 11,055
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
BurnableToken
|
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
}
}
|
/**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/
|
NatSpecMultiLine
|
burn
|
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
}
|
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
|
NatSpecMultiLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
225,
720
]
}
| 11,056
|
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
createReserveTokensVault
|
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
|
/// @dev Create a ReserveTokenVault
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
1332,
1651
]
}
| 11,057
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
createTokenVaultInt
|
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
|
/// @dev Create a TokenVault and fill with the specified newly minted tokens
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
1736,
2009
]
}
| 11,058
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
createTokensInt
|
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
|
// @dev create specified number of tokens and transfer to destination
|
LineComment
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
2087,
2459
]
}
| 11,059
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
vestTokensDetailInt
|
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
|
/// @dev vest Detail : second unit
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
2502,
3286
]
}
| 11,060
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
vestTokensStartAtInt
|
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
|
/// @dev vest StartAt : day unit
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
3327,
4308
]
}
| 11,061
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
vestTokensFromNowInt
|
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
|
/// @dev vest function from now
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
4348,
4621
]
}
| 11,062
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
vestCmdNow1PercentInt
|
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
|
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
4705,
4900
]
}
| 11,063
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
vestCmd3Month1PercentInt
|
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
|
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
5011,
5218
]
}
| 11,064
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
vestCmd1YearInstantInt
|
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
|
/// @dev vest the sale contributor tokens 100% release after 1 year
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
5294,
5498
]
}
| 11,065
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
releaseVestedTokens
|
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
|
/// @dev releases vested tokens for the caller's own address
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
5567,
5665
]
}
| 11,066
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
releaseVestedTokensFor
|
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
|
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
5782,
5906
]
}
| 11,067
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
lockedBalanceOf
|
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
|
/// @dev check the vested balance for an address
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
5963,
6092
]
}
| 11,068
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
releaseableBalanceOf
|
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
|
/// @dev check the locked but releaseable balance of an owner
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
6162,
6428
]
}
| 11,069
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
revokeVestedTokensFor
|
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
|
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
6584,
6716
]
}
| 11,070
|
||
GDS_Token
|
GDS_Token.sol
|
0xda8b3b7f6b2fee06b99c2c1916ad074365538ca5
|
Solidity
|
GDS_Token
|
contract GDS_Token is BurnableToken, Owned {
string public constant name = "GOODS";
string public constant symbol = "GDS";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated ( 100 million GDS)
uint256 public constant HARD_CAP = 100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 50 million
uint256 saleTokens = 50000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 50 million
uint256 reserveTokens = 50000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(
address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(
address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay ) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release after 3 month later, no cliff
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
|
makeReserveToVault
|
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
|
/// @dev Create a ReserveTokenVault
|
NatSpecSingleLine
|
v0.4.24+commit.e67f0147
|
Apache-2.0
|
bzzr://17cad049f83c81552496518a9d7727c7b9fcb68099b07ac1bcfd775286c28843
|
{
"func_code_index": [
6761,
6922
]
}
| 11,071
|
||
MenapayToken
|
MenapayToken.sol
|
0x211d171f769ec791629b88d33ae791226e6e9d5b
|
Solidity
|
MenapayToken
|
contract MenapayToken is Pausable, StandardToken {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
function MenapayToken(uint _initialSupply, string _name, string _symbol, uint _decimals){
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
function transfer(address _to, uint _value) whenNotPaused {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
function transferFrom(address _from, address _to, uint _value) whenNotPaused {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
function balanceOf(address who) constant returns (uint){
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
function approve(address _spender, uint _value) onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
function deprecate(address _upgradedAddress) onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() constant returns (uint){
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
function issue(uint amount) onlyOwner {
if (_totalSupply + amount < _totalSupply) throw;
if (balances[owner] + amount < balances[owner]) throw;
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
function redeem(uint amount) onlyOwner {
if (_totalSupply < amount) throw;
if (balances[owner] < amount) throw;
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) onlyOwner {
if (newBasisPoints > 20) throw;
if (newMaxFee > 50) throw;
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
event Issue(uint amount);
event Redeem(uint amount);
event Deprecate(address newAddress);
event Params(uint feeBasisPoints, uint maxFee);
}
|
totalSupply
|
function totalSupply() constant returns (uint){
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
|
// deprecate current contract if favour of a new one
|
LineComment
|
v0.4.11+commit.68ef5810
|
MIT
|
bzzr://28bda969d4e85808dd3491d3c0f204a0effe44713faf391cda61b1d7f065d9fb
|
{
"func_code_index": [
1998,
2185
]
}
| 11,072
|
||
YearnFinancePro
|
YearnFinancePro.sol
|
0x1f9c2c8145c95ede1aa30a0b958c57deaba2e002
|
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 SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
Comment
|
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.
*/
|
Comment
|
v0.4.26+commit.4563c3fc
|
None
|
bzzr://8b306da7e35993512da69bed9799be3e5bdd193e391189c0f64acd4aa20bebe6
|
{
"func_code_index": [
94,
301
]
}
| 11,073
|
YearnFinancePro
|
YearnFinancePro.sol
|
0x1f9c2c8145c95ede1aa30a0b958c57deaba2e002
|
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 SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
Comment
|
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.
*/
|
Comment
|
v0.4.26+commit.4563c3fc
|
None
|
bzzr://8b306da7e35993512da69bed9799be3e5bdd193e391189c0f64acd4aa20bebe6
|
{
"func_code_index": [
390,
690
]
}
| 11,074
|
YearnFinancePro
|
YearnFinancePro.sol
|
0x1f9c2c8145c95ede1aa30a0b958c57deaba2e002
|
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 SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
Comment
|
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).
*/
|
Comment
|
v0.4.26+commit.4563c3fc
|
None
|
bzzr://8b306da7e35993512da69bed9799be3e5bdd193e391189c0f64acd4aa20bebe6
|
{
"func_code_index": [
809,
937
]
}
| 11,075
|
YearnFinancePro
|
YearnFinancePro.sol
|
0x1f9c2c8145c95ede1aa30a0b958c57deaba2e002
|
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 SafeMath
* @dev Math operations with safety checks that throw on error
*/
|
Comment
|
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.
*/
|
Comment
|
v0.4.26+commit.4563c3fc
|
None
|
bzzr://8b306da7e35993512da69bed9799be3e5bdd193e391189c0f64acd4aa20bebe6
|
{
"func_code_index": [
1006,
1152
]
}
| 11,076
|
Doggo
|
@openzeppelin/contracts/access/Ownable.sol
|
0x46ccb782da782b9e921dd447736ab64fc4fb2636
|
Solidity
|
Ownable
|
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
|
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
|
NatSpecMultiLine
|
owner
|
function owner() public view virtual returns (address) {
return _owner;
}
|
/**
* @dev Returns the address of the current owner.
*/
|
NatSpecMultiLine
|
v0.8.11+commit.d7f03943
|
MIT
|
ipfs://b7bbd7ee9ab1542a8a2cb4bb6c14579b679e08db33719593c8b0618bf852ee99
|
{
"func_code_index": [
408,
500
]
}
| 11,077
|
Doggo
|
@openzeppelin/contracts/access/Ownable.sol
|
0x46ccb782da782b9e921dd447736ab64fc4fb2636
|
Solidity
|
Ownable
|
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
|
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
|
NatSpecMultiLine
|
renounceOwnership
|
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
|
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
|
NatSpecMultiLine
|
v0.8.11+commit.d7f03943
|
MIT
|
ipfs://b7bbd7ee9ab1542a8a2cb4bb6c14579b679e08db33719593c8b0618bf852ee99
|
{
"func_code_index": [
1059,
1167
]
}
| 11,078
|
Doggo
|
@openzeppelin/contracts/access/Ownable.sol
|
0x46ccb782da782b9e921dd447736ab64fc4fb2636
|
Solidity
|
Ownable
|
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
|
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
|
NatSpecMultiLine
|
transferOwnership
|
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
|
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
|
NatSpecMultiLine
|
v0.8.11+commit.d7f03943
|
MIT
|
ipfs://b7bbd7ee9ab1542a8a2cb4bb6c14579b679e08db33719593c8b0618bf852ee99
|
{
"func_code_index": [
1317,
1523
]
}
| 11,079
|
Doggo
|
@openzeppelin/contracts/access/Ownable.sol
|
0x46ccb782da782b9e921dd447736ab64fc4fb2636
|
Solidity
|
Ownable
|
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
|
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
|
NatSpecMultiLine
|
_transferOwnership
|
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
|
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
|
NatSpecMultiLine
|
v0.8.11+commit.d7f03943
|
MIT
|
ipfs://b7bbd7ee9ab1542a8a2cb4bb6c14579b679e08db33719593c8b0618bf852ee99
|
{
"func_code_index": [
1678,
1874
]
}
| 11,080
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
Address
|
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
|
/**
* @dev Collection of functions related to the address type
*/
|
NatSpecMultiLine
|
isContract
|
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
|
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
|
NatSpecMultiLine
|
v0.6.12+commit.27d51765
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
606,
1230
]
}
| 11,081
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
Address
|
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
|
/**
* @dev Collection of functions related to the address type
*/
|
NatSpecMultiLine
|
sendValue
|
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
|
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
|
NatSpecMultiLine
|
v0.6.12+commit.27d51765
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
2160,
2562
]
}
| 11,082
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
Proxy
|
abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() internal virtual 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() internal virtual {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
_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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
114,
170
]
}
| 11,083
|
||
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
Proxy
|
abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() internal virtual 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() internal virtual {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
_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() internal virtual view returns (address);
|
/**
* @return The Address of the implementation.
*/
|
NatSpecMultiLine
|
v0.6.12+commit.27d51765
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
236,
306
]
}
| 11,084
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
Proxy
|
abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() internal virtual 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() internal virtual {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
_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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
597,
1362
]
}
| 11,085
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
Proxy
|
abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() internal virtual 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() internal virtual {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
_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() internal virtual {
}
|
/**
* @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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
1575,
1626
]
}
| 11,086
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
Proxy
|
abstract contract Proxy {
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback () payable external {
_fallback();
}
/**
* @return The Address of the implementation.
*/
function _implementation() internal virtual 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() internal virtual {
}
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
function _fallback() internal {
_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 {
_willFallback();
_delegate(_implementation());
}
|
/**
* @dev fallback implementation.
* Extracted to enable manual triggering.
*/
|
NatSpecMultiLine
|
v0.6.12+commit.27d51765
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
1724,
1820
]
}
| 11,087
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
BaseUpgradeabilityProxy
|
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() internal override 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(Address.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() internal override 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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
684,
857
]
}
| 11,088
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
BaseUpgradeabilityProxy
|
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() internal override 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(Address.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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
995,
1143
]
}
| 11,089
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
BaseUpgradeabilityProxy
|
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() internal override 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(Address.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(Address.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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
1283,
1579
]
}
| 11,090
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
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() internal override virtual {
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
989,
1072
]
}
| 11,091
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
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() internal override virtual {
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
1138,
1239
]
}
| 11,092
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
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() internal override virtual {
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
1419,
1650
]
}
| 11,093
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
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() internal override virtual {
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
1838,
1946
]
}
| 11,094
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
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() internal override virtual {
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
2471,
2699
]
}
| 11,095
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
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() internal override virtual {
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
2750,
2894
]
}
| 11,096
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
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() internal override virtual {
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
3013,
3155
]
}
| 11,097
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
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() internal override virtual {
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() internal override virtual {
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
3232,
3412
]
}
| 11,098
|
InitializableAdminUpgradeabilityProxy
|
InitializableAdminUpgradeabilityProxy.sol
|
0xcd55262c3ea354a58661597f71037d5fa26b72bd
|
Solidity
|
InitializableUpgradeabilityProxy
|
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
|
Unknown
|
ipfs://5b70184b910b61c840297871c0fa5a4d6a4c004bea856b7718f824c27cb83b4f
|
{
"func_code_index": [
604,
1016
]
}
| 11,099
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.