Unnamed: 0 int64 0 7.36k | comments stringlengths 3 35.2k | code_string stringlengths 1 527k | code stringlengths 1 527k | __index_level_0__ int64 0 88.6k |
|---|---|---|---|---|
16 | // Update the product | products[_id] = _product;
| products[_id] = _product;
| 41,440 |
138 | // Create event | eventContract = new CategoricalEvent(
collateralToken,
oracle,
outcomeCount
);
categoricalEvents[eventHash] = eventContract;
CategoricalEventCreation(msg.sender, eventContract, collateralToken, oracle, outcomeCount);
| eventContract = new CategoricalEvent(
collateralToken,
oracle,
outcomeCount
);
categoricalEvents[eventHash] = eventContract;
CategoricalEventCreation(msg.sender, eventContract, collateralToken, oracle, outcomeCount);
| 42,646 |
2 | // Setting the version as a function so that it can be overriden | function version() public pure virtual returns(string memory) { return "1"; }
/**
* @dev See {IERC2612-permit}.
*
* In cases where the free option is not a concern, deadline can simply be
* set to uint(-1), so it should be seen as an optional parameter
*/
function permit(
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(deadline >= block.timestamp, "ERC20Permit: expired deadline");
bytes32 hashStruct = keccak256(
abi.encode(
PERMIT_TYPEHASH,
owner,
spender,
amount,
nonces[owner]++,
deadline
)
);
bytes32 hash = keccak256(
abi.encodePacked(
'\x19',
'\x01',
DOMAIN_SEPARATOR,
hashStruct
)
);
address signer = ecrecover(hash, v, r, s);
require(
signer != address(0),
"ERC20Permit: signer cant be address 0"
);
require(
signer == owner,
"ERC20Permit: signer must be the owner"
);
_approve(owner, spender, amount);
}
| function version() public pure virtual returns(string memory) { return "1"; }
/**
* @dev See {IERC2612-permit}.
*
* In cases where the free option is not a concern, deadline can simply be
* set to uint(-1), so it should be seen as an optional parameter
*/
function permit(
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(deadline >= block.timestamp, "ERC20Permit: expired deadline");
bytes32 hashStruct = keccak256(
abi.encode(
PERMIT_TYPEHASH,
owner,
spender,
amount,
nonces[owner]++,
deadline
)
);
bytes32 hash = keccak256(
abi.encodePacked(
'\x19',
'\x01',
DOMAIN_SEPARATOR,
hashStruct
)
);
address signer = ecrecover(hash, v, r, s);
require(
signer != address(0),
"ERC20Permit: signer cant be address 0"
);
require(
signer == owner,
"ERC20Permit: signer must be the owner"
);
_approve(owner, spender, amount);
}
| 11,334 |
12 | // Reset the staking end time | delete stakers[msg.sender];
userStakedCounter--;
| delete stakers[msg.sender];
userStakedCounter--;
| 26,062 |
30 | // BlokkoContracts takes Smartys token in escrow from client and supplier./Both can claim the tokens if they send a valid signed message. | contract BlokkoOrder is IERC777Recipient, IERC777Sender, ERC1820Implementer {
IERC1820Registry private _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
bytes32 constant public TOKENS_SENDER_INTERFACE_HASH = keccak256("ERC777TokensSender");
IERC777 public blokkoToken;
/// @dev Link contract to Smartys token.
/// @dev For a smart contract to receive ERC777 tokens, it needs to implement the tokensReceived hook and register with ERC1820 registry as an ERC777TokensRecipient
constructor (IERC777 tokenAddress) public {
blokkoToken = IERC777(tokenAddress);
_erc1820.setInterfaceImplementer(address(this), TOKENS_RECIPIENT_INTERFACE_HASH, address(this));
}
using SafeMath for uint256;
function bytesToUint(bytes memory userData) public pure returns (uint256 number) {
number=0;
for(uint i=0;i<userData.length;i++){
number *= 256;
number += uint(uint8(userData[i]));
}
}
function uintToBytes(uint256 x) public pure returns (bytes memory b) {
b = new bytes(32);
for (uint i = 0; i < 32; i++) {
b[i] = byte(uint8(x / (2**(8*(31 - i)))));
}
}
function senderFor(address account) public {
_registerInterfaceForAddress(TOKENS_SENDER_INTERFACE_HASH, account);
}
event DoneStuff(address operator, address from, address to, uint256 amount, bytes userData, bytes operatorData);
function tokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
) public {
emit DoneStuff(operator, from, to, amount, userData, operatorData);
}
/// @dev Define contract parameters.
/// @param orderID Contract nonce to prevent replay attack (make sure escrow can only be claimed successfully once).
uint256 orderID;
/// @dev Define order status parameters.
/// @param escrowPaid Set to true when client has paid escrow. By default initialized to `false`.
/// @param orderPaid Set to true after order is settled. By default initialized to `false`.
/// @param orderEnded Set to true after order is settled or cancelled, disallows any change. By default initialized to `false`.
/// @param status Sets status of the order. Possible values: `1-registered, 2-escrowPaid, 3-deliveredInTime, 4-deliveredLate, 5-cancelled`.
/// @param deliveryEnd Timestamp of registry of transport delivery.
struct OrderStatus {
uint256 deliveryEnd;
uint256 finalCostPaid;
bool escrowPaid;
bool orderPaid;
bool orderEnded;
string status;
}
/// @param OrderData Array of dynamic size to capture the contract data for a specific order.
/// @param orderAmount Escrowed by client, can be claimed by supplier if client confirms delivery.
/// @param goodsReceived True when valid signed message by client is received.
/// @param deliveryStart Timestamp of registry of transport start.
/// @param deliveryTime Maximum agreed delivery timestamp.
struct OrderData {
string sessionUuid;
address supplier;
address client;
uint256 orderAmount;
uint256 transportAmount;
string ipfsOrderHash;
uint256 transportTime;
uint256 deliveryStart;
uint256 deliveryTime;
OrderStatus status;
}
mapping (uint256 => OrderData) public orders;
uint256[] public orderIDs;
/// @notice Register order parameters and store in struct
/// @param _transportTime Transport time in seconds.
/// @return orderID that is increased by 1 for every new order registered
event newOrder(uint256 orderID, string status);
function defineOrder(
string memory _sessionUuid,
address _supplier_address,
uint256 _orderAmount,
uint256 _transportAmount,
uint256 _transportTime,
string memory _ipfsOrderHash
) public returns(uint256) {
/// @dev set orderID.status
orderID++;
/// @dev set order parameters
orders[orderID].sessionUuid = _sessionUuid;
orders[orderID].supplier = _supplier_address;
orders[orderID].client = msg.sender;
orders[orderID].transportAmount = _transportAmount;
orders[orderID].orderAmount = _orderAmount;
orders[orderID].transportTime = _transportTime;
orders[orderID].ipfsOrderHash = _ipfsOrderHash;
orders[orderID].status.status = "1-registered";
/// @dev push the new orderId to the array of uints orderIDs
orderIDs.push(orderID);
emit newOrder(orderID, orders[orderID].status.status);
}
function getOrderIDs() view public returns(uint256[] memory){
return orderIDs;
}
function storeIPFSOrderHash(
uint256 _selectedOrderID,
string memory _ipfsOrderHash
) public {
// set parameters
orders[_selectedOrderID].ipfsOrderHash = _ipfsOrderHash;
}
/// @dev Code from https://forum.openzeppelin.com/t/simple-erc777-token-example/746
event receivedTokens(string text, address operator, address from, address to, uint256 amount, bytes userData, bytes operatorData);
event clientDeposited(string status, uint256 orderID, uint256 _deliveryStart, uint256 _deliveryTime);
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData, // asume only uint
bytes calldata operatorData
) external {
uint256 _selectedOrderID = bytesToUint(userData);
uint256 _escrowAmount = orders[_selectedOrderID].orderAmount.add(orders[_selectedOrderID].transportAmount);
/// @dev set order parameters
uint256 _deliveryStart = uint64(block.timestamp);
orders[_selectedOrderID].deliveryStart = _deliveryStart;
orders[_selectedOrderID].deliveryTime = _deliveryStart.add(orders[_selectedOrderID].transportTime);
// check conditions
require(msg.sender == address(blokkoToken), "Simple777Recipient: Invalid ERC777 token");
require(from == orders[_selectedOrderID].client, "Payment not made by client");
require(amount == _escrowAmount, "Escrow payment is not the same as the order amount");
require(orders[_selectedOrderID].status.escrowPaid == false, "Escrow is already deposited");
require(orders[_selectedOrderID].status.orderEnded == false, "Order is already ended");
emit receivedTokens("tokensReceived", operator, from, to, amount, userData, operatorData);
// register payment
orders[_selectedOrderID].status.escrowPaid = true;
orders[_selectedOrderID].status.status = "2-escrowPaid";
emit clientDeposited(orders[_selectedOrderID].status.status, _selectedOrderID, _deliveryStart, orders[_selectedOrderID].deliveryTime);
}
/// @notice Register delivery timestamp and settle payments
event transportReceived(string status, uint orderID, bool orderEnded, uint256 finalCostPaid);
function recieveTransport(bytes memory userData) public {
uint256 _selectedOrderID = bytesToUint(userData);
uint256 _deliveryEnd = uint64(block.timestamp);
uint256 _totalAmount = orders[_selectedOrderID].transportAmount.add(orders[_selectedOrderID].orderAmount);
require(msg.sender == orders[_selectedOrderID].client, "Only client can register transport receipt");
require(orders[_selectedOrderID].status.escrowPaid == true, "No escrow has been deposited");
require(orders[_selectedOrderID].status.orderEnded == false, "Transport already ended");
if (_deliveryEnd <= orders[_selectedOrderID].deliveryTime ) {
// Scenario green
blokkoToken.send(orders[_selectedOrderID].supplier, _totalAmount, userData);
orders[_selectedOrderID].status.finalCostPaid = _totalAmount;
orders[_selectedOrderID].status.status = "3-deliveredInTime";
} else {
// Scenario red
blokkoToken.send(orders[_selectedOrderID].supplier, orders[_selectedOrderID].orderAmount, userData);
blokkoToken.send(orders[_selectedOrderID].client, orders[_selectedOrderID].transportAmount, userData);
orders[_selectedOrderID].status.finalCostPaid = orders[_selectedOrderID].orderAmount;
orders[_selectedOrderID].status.status = "4-deliveredLate";
}
orders[_selectedOrderID].status.deliveryEnd = _deliveryEnd;
orders[_selectedOrderID].status.orderEnded = true;
emit transportReceived(orders[_selectedOrderID].status.status, _selectedOrderID, orders[_selectedOrderID].status.orderEnded, orders[_selectedOrderID].status.finalCostPaid);
}
/// @notice Register cancel order by client and settle payments
event orderCancelled(string status, uint orderID, bool _orderEnded);
function cancelOrder(bytes memory userData) public {
uint256 _selectedOrderID = bytesToUint(userData);
uint256 _deliveryEnd = uint64(block.timestamp);
uint256 _totalAmount = orders[_selectedOrderID].transportAmount.add(orders[_selectedOrderID].orderAmount);
require(msg.sender == orders[_selectedOrderID].client, "Only client can call this function.");
require(orders[_selectedOrderID].status.escrowPaid == true, "No escrow has been deposited.");
require(orders[_selectedOrderID].status.orderEnded == false, "Transport already ended.");
if (_deliveryEnd <= orders[_selectedOrderID].deliveryTime ) {
// Scenario green: cancelled within delivery time
blokkoToken.send(orders[_selectedOrderID].client, orders[_selectedOrderID].orderAmount, userData);
blokkoToken.send(orders[_selectedOrderID].supplier, orders[_selectedOrderID].transportAmount, userData);
} else {
// Scenario red: cancelled outside delivery time
blokkoToken.send(orders[_selectedOrderID].client, _totalAmount, userData);
}
orders[_selectedOrderID].status.orderEnded = true;
orders[_selectedOrderID].status.status = "5-cancelled";
emit orderCancelled(orders[_selectedOrderID].status.status, _selectedOrderID, orders[_selectedOrderID].status.orderEnded);
}
event depositedStatus(bool escrowPaid);
function depositStatus(uint256 _selectedOrderID) public /* onlyBy(client) */ {
bool _escrowPaid = orders[_selectedOrderID].status.escrowPaid;
emit depositedStatus(_escrowPaid);
}
} | contract BlokkoOrder is IERC777Recipient, IERC777Sender, ERC1820Implementer {
IERC1820Registry private _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
bytes32 constant public TOKENS_SENDER_INTERFACE_HASH = keccak256("ERC777TokensSender");
IERC777 public blokkoToken;
/// @dev Link contract to Smartys token.
/// @dev For a smart contract to receive ERC777 tokens, it needs to implement the tokensReceived hook and register with ERC1820 registry as an ERC777TokensRecipient
constructor (IERC777 tokenAddress) public {
blokkoToken = IERC777(tokenAddress);
_erc1820.setInterfaceImplementer(address(this), TOKENS_RECIPIENT_INTERFACE_HASH, address(this));
}
using SafeMath for uint256;
function bytesToUint(bytes memory userData) public pure returns (uint256 number) {
number=0;
for(uint i=0;i<userData.length;i++){
number *= 256;
number += uint(uint8(userData[i]));
}
}
function uintToBytes(uint256 x) public pure returns (bytes memory b) {
b = new bytes(32);
for (uint i = 0; i < 32; i++) {
b[i] = byte(uint8(x / (2**(8*(31 - i)))));
}
}
function senderFor(address account) public {
_registerInterfaceForAddress(TOKENS_SENDER_INTERFACE_HASH, account);
}
event DoneStuff(address operator, address from, address to, uint256 amount, bytes userData, bytes operatorData);
function tokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
) public {
emit DoneStuff(operator, from, to, amount, userData, operatorData);
}
/// @dev Define contract parameters.
/// @param orderID Contract nonce to prevent replay attack (make sure escrow can only be claimed successfully once).
uint256 orderID;
/// @dev Define order status parameters.
/// @param escrowPaid Set to true when client has paid escrow. By default initialized to `false`.
/// @param orderPaid Set to true after order is settled. By default initialized to `false`.
/// @param orderEnded Set to true after order is settled or cancelled, disallows any change. By default initialized to `false`.
/// @param status Sets status of the order. Possible values: `1-registered, 2-escrowPaid, 3-deliveredInTime, 4-deliveredLate, 5-cancelled`.
/// @param deliveryEnd Timestamp of registry of transport delivery.
struct OrderStatus {
uint256 deliveryEnd;
uint256 finalCostPaid;
bool escrowPaid;
bool orderPaid;
bool orderEnded;
string status;
}
/// @param OrderData Array of dynamic size to capture the contract data for a specific order.
/// @param orderAmount Escrowed by client, can be claimed by supplier if client confirms delivery.
/// @param goodsReceived True when valid signed message by client is received.
/// @param deliveryStart Timestamp of registry of transport start.
/// @param deliveryTime Maximum agreed delivery timestamp.
struct OrderData {
string sessionUuid;
address supplier;
address client;
uint256 orderAmount;
uint256 transportAmount;
string ipfsOrderHash;
uint256 transportTime;
uint256 deliveryStart;
uint256 deliveryTime;
OrderStatus status;
}
mapping (uint256 => OrderData) public orders;
uint256[] public orderIDs;
/// @notice Register order parameters and store in struct
/// @param _transportTime Transport time in seconds.
/// @return orderID that is increased by 1 for every new order registered
event newOrder(uint256 orderID, string status);
function defineOrder(
string memory _sessionUuid,
address _supplier_address,
uint256 _orderAmount,
uint256 _transportAmount,
uint256 _transportTime,
string memory _ipfsOrderHash
) public returns(uint256) {
/// @dev set orderID.status
orderID++;
/// @dev set order parameters
orders[orderID].sessionUuid = _sessionUuid;
orders[orderID].supplier = _supplier_address;
orders[orderID].client = msg.sender;
orders[orderID].transportAmount = _transportAmount;
orders[orderID].orderAmount = _orderAmount;
orders[orderID].transportTime = _transportTime;
orders[orderID].ipfsOrderHash = _ipfsOrderHash;
orders[orderID].status.status = "1-registered";
/// @dev push the new orderId to the array of uints orderIDs
orderIDs.push(orderID);
emit newOrder(orderID, orders[orderID].status.status);
}
function getOrderIDs() view public returns(uint256[] memory){
return orderIDs;
}
function storeIPFSOrderHash(
uint256 _selectedOrderID,
string memory _ipfsOrderHash
) public {
// set parameters
orders[_selectedOrderID].ipfsOrderHash = _ipfsOrderHash;
}
/// @dev Code from https://forum.openzeppelin.com/t/simple-erc777-token-example/746
event receivedTokens(string text, address operator, address from, address to, uint256 amount, bytes userData, bytes operatorData);
event clientDeposited(string status, uint256 orderID, uint256 _deliveryStart, uint256 _deliveryTime);
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData, // asume only uint
bytes calldata operatorData
) external {
uint256 _selectedOrderID = bytesToUint(userData);
uint256 _escrowAmount = orders[_selectedOrderID].orderAmount.add(orders[_selectedOrderID].transportAmount);
/// @dev set order parameters
uint256 _deliveryStart = uint64(block.timestamp);
orders[_selectedOrderID].deliveryStart = _deliveryStart;
orders[_selectedOrderID].deliveryTime = _deliveryStart.add(orders[_selectedOrderID].transportTime);
// check conditions
require(msg.sender == address(blokkoToken), "Simple777Recipient: Invalid ERC777 token");
require(from == orders[_selectedOrderID].client, "Payment not made by client");
require(amount == _escrowAmount, "Escrow payment is not the same as the order amount");
require(orders[_selectedOrderID].status.escrowPaid == false, "Escrow is already deposited");
require(orders[_selectedOrderID].status.orderEnded == false, "Order is already ended");
emit receivedTokens("tokensReceived", operator, from, to, amount, userData, operatorData);
// register payment
orders[_selectedOrderID].status.escrowPaid = true;
orders[_selectedOrderID].status.status = "2-escrowPaid";
emit clientDeposited(orders[_selectedOrderID].status.status, _selectedOrderID, _deliveryStart, orders[_selectedOrderID].deliveryTime);
}
/// @notice Register delivery timestamp and settle payments
event transportReceived(string status, uint orderID, bool orderEnded, uint256 finalCostPaid);
function recieveTransport(bytes memory userData) public {
uint256 _selectedOrderID = bytesToUint(userData);
uint256 _deliveryEnd = uint64(block.timestamp);
uint256 _totalAmount = orders[_selectedOrderID].transportAmount.add(orders[_selectedOrderID].orderAmount);
require(msg.sender == orders[_selectedOrderID].client, "Only client can register transport receipt");
require(orders[_selectedOrderID].status.escrowPaid == true, "No escrow has been deposited");
require(orders[_selectedOrderID].status.orderEnded == false, "Transport already ended");
if (_deliveryEnd <= orders[_selectedOrderID].deliveryTime ) {
// Scenario green
blokkoToken.send(orders[_selectedOrderID].supplier, _totalAmount, userData);
orders[_selectedOrderID].status.finalCostPaid = _totalAmount;
orders[_selectedOrderID].status.status = "3-deliveredInTime";
} else {
// Scenario red
blokkoToken.send(orders[_selectedOrderID].supplier, orders[_selectedOrderID].orderAmount, userData);
blokkoToken.send(orders[_selectedOrderID].client, orders[_selectedOrderID].transportAmount, userData);
orders[_selectedOrderID].status.finalCostPaid = orders[_selectedOrderID].orderAmount;
orders[_selectedOrderID].status.status = "4-deliveredLate";
}
orders[_selectedOrderID].status.deliveryEnd = _deliveryEnd;
orders[_selectedOrderID].status.orderEnded = true;
emit transportReceived(orders[_selectedOrderID].status.status, _selectedOrderID, orders[_selectedOrderID].status.orderEnded, orders[_selectedOrderID].status.finalCostPaid);
}
/// @notice Register cancel order by client and settle payments
event orderCancelled(string status, uint orderID, bool _orderEnded);
function cancelOrder(bytes memory userData) public {
uint256 _selectedOrderID = bytesToUint(userData);
uint256 _deliveryEnd = uint64(block.timestamp);
uint256 _totalAmount = orders[_selectedOrderID].transportAmount.add(orders[_selectedOrderID].orderAmount);
require(msg.sender == orders[_selectedOrderID].client, "Only client can call this function.");
require(orders[_selectedOrderID].status.escrowPaid == true, "No escrow has been deposited.");
require(orders[_selectedOrderID].status.orderEnded == false, "Transport already ended.");
if (_deliveryEnd <= orders[_selectedOrderID].deliveryTime ) {
// Scenario green: cancelled within delivery time
blokkoToken.send(orders[_selectedOrderID].client, orders[_selectedOrderID].orderAmount, userData);
blokkoToken.send(orders[_selectedOrderID].supplier, orders[_selectedOrderID].transportAmount, userData);
} else {
// Scenario red: cancelled outside delivery time
blokkoToken.send(orders[_selectedOrderID].client, _totalAmount, userData);
}
orders[_selectedOrderID].status.orderEnded = true;
orders[_selectedOrderID].status.status = "5-cancelled";
emit orderCancelled(orders[_selectedOrderID].status.status, _selectedOrderID, orders[_selectedOrderID].status.orderEnded);
}
event depositedStatus(bool escrowPaid);
function depositStatus(uint256 _selectedOrderID) public /* onlyBy(client) */ {
bool _escrowPaid = orders[_selectedOrderID].status.escrowPaid;
emit depositedStatus(_escrowPaid);
}
} | 42,216 |
22 | // map requestId to Selection | mapping (uint256 => Selection) public _selections;
| mapping (uint256 => Selection) public _selections;
| 15,917 |
262 | // This method can be used by the controller to extract mistakenly/sent tokens to this contract. | function claimTokens(address _tokenAddr) public onlyController {
ERC20Basic some_token = ERC20Basic(_tokenAddr);
uint256 balance = some_token.balanceOf(this);
some_token.transfer(controller, balance);
ClaimedTokens(_tokenAddr, controller, balance);
}
| function claimTokens(address _tokenAddr) public onlyController {
ERC20Basic some_token = ERC20Basic(_tokenAddr);
uint256 balance = some_token.balanceOf(this);
some_token.transfer(controller, balance);
ClaimedTokens(_tokenAddr, controller, balance);
}
| 18,560 |
489 | // Callback loanManager and cosign | require(_loanManager.cosign(_debtId, 0), "collateral: error during cosign");
| require(_loanManager.cosign(_debtId, 0), "collateral: error during cosign");
| 25,731 |
18 | // add the ambassadors here. rackoo - lead solidity dev & lead web dev. | ambassadors_[0xbe3569068562218c792cf25b98dbf1418aff2455] = true;
| ambassadors_[0xbe3569068562218c792cf25b98dbf1418aff2455] = true;
| 53,014 |
23 | // sender needs to approve this contract to fund the claim | require(_beneficiary != address(0), "Beneficiary is required");
require(_amount > 0, "Amount is required");
require(_vesting >= _cliff, "Vesting period should be equal or longer to the cliff");
ERC20 token = ERC20(_token);
require(token.balanceOf(msg.sender) >= _amount, "Insufficient balance");
require(token.transferFrom(msg.sender, address(this), _amount), "Funding failed.");
ticketId = ++currentId;
Ticket storage ticket = tickets[ticketId];
ticket.token = _token;
ticket.grantor = msg.sender;
| require(_beneficiary != address(0), "Beneficiary is required");
require(_amount > 0, "Amount is required");
require(_vesting >= _cliff, "Vesting period should be equal or longer to the cliff");
ERC20 token = ERC20(_token);
require(token.balanceOf(msg.sender) >= _amount, "Insufficient balance");
require(token.transferFrom(msg.sender, address(this), _amount), "Funding failed.");
ticketId = ++currentId;
Ticket storage ticket = tickets[ticketId];
ticket.token = _token;
ticket.grantor = msg.sender;
| 41,153 |
0 | // struct to add matchoutcomes | struct Match {
string name;
uint winner;
}
| struct Match {
string name;
uint winner;
}
| 9,393 |
39 | // Ropsten | IUniswapFactory uniFactory = IUniswapFactory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IMasterChef masterChef = IMasterChef(0xFF281cEF43111A83f09C656734Fa03E6375d432A);
ISushiToken sushi = ISushiToken(0x81DB9C598b3ebbdC92426422fc0A1d06E77195ec);
address WETH = 0x078A84ee7991699DD198B7b95055AEd0C782A6eE;
| IUniswapFactory uniFactory = IUniswapFactory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IMasterChef masterChef = IMasterChef(0xFF281cEF43111A83f09C656734Fa03E6375d432A);
ISushiToken sushi = ISushiToken(0x81DB9C598b3ebbdC92426422fc0A1d06E77195ec);
address WETH = 0x078A84ee7991699DD198B7b95055AEd0C782A6eE;
| 10,646 |
176 | // Internal call to borrow tokens from the bank on behalf of the current executor./token The token to borrow from the bank./amount The amount to borrow./Do not use `amount` input argument to handle the received amount. | function doBorrow(address token, uint amount) internal {
if (amount > 0) {
bank.borrow(token, amount);
}
}
| function doBorrow(address token, uint amount) internal {
if (amount > 0) {
bank.borrow(token, amount);
}
}
| 33,112 |
5 | // Multiplies two wad, rounding half up to the nearest wad a Wad b Wadreturn The result of ab, in wad / | function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
require(a <= (type(uint256).max - halfWAD) / b, 'Errors.MATH_MULTIPLICATION_OVERFLOW');
return (a * b + halfWAD) / WAD;
}
| function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
require(a <= (type(uint256).max - halfWAD) / b, 'Errors.MATH_MULTIPLICATION_OVERFLOW');
return (a * b + halfWAD) / WAD;
}
| 12,334 |
31 | // Child contract can enable to provide the condition when the upgrade can begun./ | function canUpgrade() public view returns(bool) {
return true;
}
| function canUpgrade() public view returns(bool) {
return true;
}
| 16,926 |
465 | // -- Accounts -- | function getNumAccounts()
external
view
returns (uint)
| function getNumAccounts()
external
view
returns (uint)
| 26,568 |
277 | // Clock auction modified for sale of kitties/We omit a fallback function to prevent accidental sends to this contract. | contract SaleClockAuction is ClockAuction {
// @dev Sanity check that allows us to ensure that we are pointing to the
// right auction in our setSaleAuctionAddress() call.
bool public isSaleClockAuction = true;
// Tracks last 5 sale price of gen0 kitty sales
uint256 public gen0SaleCount;
uint256[5] public lastGen0SalePrices;
// Delegate constructor
function SaleClockAuction(address _nftAddr, uint256 _cut) public
ClockAuction(_nftAddr, _cut) {}
/// @dev Creates and begins a new auction.
/// @param _tokenId - ID of token to auction, sender must be owner.
/// @param _startingPrice - Price of item (in wei) at beginning of auction.
/// @param _endingPrice - Price of item (in wei) at end of auction.
/// @param _duration - Length of auction (in seconds).
/// @param _seller - Seller, if not the message sender
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
{
// Sanity check that no inputs overflow how many bits we've allocated
// to store them in the auction struct.
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(msg.sender == address(nonFungibleContract));
_escrow(_seller, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
/// @dev Updates lastSalePrice if seller is the nft contract
/// Otherwise, works the same as default bid method.
function bid(uint256 _tokenId)
external
payable
{
// _bid verifies token ID size
address seller = tokenIdToAuction[_tokenId].seller;
uint256 price = _bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
// If not a gen0 auction, exit
if (seller == address(nonFungibleContract)) {
// Track gen0 sale prices
lastGen0SalePrices[gen0SaleCount % 5] = price;
gen0SaleCount++;
}
}
function averageGen0SalePrice() external view returns (uint256) {
uint256 sum = 0;
for (uint256 i = 0; i < 5; i++) {
sum += lastGen0SalePrices[i];
}
return sum / 5;
}
}
| contract SaleClockAuction is ClockAuction {
// @dev Sanity check that allows us to ensure that we are pointing to the
// right auction in our setSaleAuctionAddress() call.
bool public isSaleClockAuction = true;
// Tracks last 5 sale price of gen0 kitty sales
uint256 public gen0SaleCount;
uint256[5] public lastGen0SalePrices;
// Delegate constructor
function SaleClockAuction(address _nftAddr, uint256 _cut) public
ClockAuction(_nftAddr, _cut) {}
/// @dev Creates and begins a new auction.
/// @param _tokenId - ID of token to auction, sender must be owner.
/// @param _startingPrice - Price of item (in wei) at beginning of auction.
/// @param _endingPrice - Price of item (in wei) at end of auction.
/// @param _duration - Length of auction (in seconds).
/// @param _seller - Seller, if not the message sender
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
{
// Sanity check that no inputs overflow how many bits we've allocated
// to store them in the auction struct.
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(msg.sender == address(nonFungibleContract));
_escrow(_seller, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
/// @dev Updates lastSalePrice if seller is the nft contract
/// Otherwise, works the same as default bid method.
function bid(uint256 _tokenId)
external
payable
{
// _bid verifies token ID size
address seller = tokenIdToAuction[_tokenId].seller;
uint256 price = _bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
// If not a gen0 auction, exit
if (seller == address(nonFungibleContract)) {
// Track gen0 sale prices
lastGen0SalePrices[gen0SaleCount % 5] = price;
gen0SaleCount++;
}
}
function averageGen0SalePrice() external view returns (uint256) {
uint256 sum = 0;
for (uint256 i = 0; i < 5; i++) {
sum += lastGen0SalePrices[i];
}
return sum / 5;
}
}
| 14,709 |
117 | // Returns total collateral locked via this strategy | function totalLocked() public view virtual override returns (uint256) {
return convertFrom18(cm.getVaultBalance(vaultNum));
}
| function totalLocked() public view virtual override returns (uint256) {
return convertFrom18(cm.getVaultBalance(vaultNum));
}
| 24,828 |
8 | // 10% bonus for every 1% of the company that you own .. total jobs owned must be > 1 returns a percent | uint _result = 0;
if (_numOwned > 1)
_result = (_numOwned * 100 / _capacity) * 10;
return Math.min(_result, MAX_TEAMWORK_BONUS);
| uint _result = 0;
if (_numOwned > 1)
_result = (_numOwned * 100 / _capacity) * 10;
return Math.min(_result, MAX_TEAMWORK_BONUS);
| 29,797 |
18 | // wallet who has control on the extension and treasury | address internal _host;
address internal _treasury;
| address internal _host;
address internal _treasury;
| 22,789 |
73 | // I'm just a man who loves "default variables" | function reinvestPartial(uint256 ethToReinvest) public returns(uint256) {
return reinvestPartial(ethToReinvest, true);
}
| function reinvestPartial(uint256 ethToReinvest) public returns(uint256) {
return reinvestPartial(ethToReinvest, true);
}
| 21,484 |
135 | // require(_msgSender() == owner() || _msgSender() == _rebaser, "Sender not authorized"); |
_epoch = _epoch.add(1);
if (supplyDelta == 0) {
emit LogRebase(_epoch, _totalSupply);
return _totalSupply;
}
|
_epoch = _epoch.add(1);
if (supplyDelta == 0) {
emit LogRebase(_epoch, _totalSupply);
return _totalSupply;
}
| 11,205 |
17 | // A mapping from CryptonIDs to the price of the token. | mapping (uint256 => uint256) private cryptonIndexToPrice;
| mapping (uint256 => uint256) private cryptonIndexToPrice;
| 39,902 |
96 | // Bet bear position epoch: epoch / | function betBear(uint256 epoch) external payable whenNotPaused nonReentrant notContract {
require(epoch == currentEpoch, "Bet is too early/late");
require(_bettable(epoch), "Round not bettable");
require(msg.value >= minBetAmount, "Bet amount must be greater than minBetAmount");
require(ledger[epoch][msg.sender].amount == 0, "Can only bet once per round");
// Update round data
uint256 amount = msg.value;
Round storage round = rounds[epoch];
round.totalAmount = round.totalAmount + amount;
round.bearAmount = round.bearAmount + amount;
// Update user data
BetInfo storage betInfo = ledger[epoch][msg.sender];
betInfo.position = Position.Bear;
betInfo.amount = amount;
userRounds[msg.sender].push(epoch);
emit BetBear(msg.sender, epoch, amount);
}
| function betBear(uint256 epoch) external payable whenNotPaused nonReentrant notContract {
require(epoch == currentEpoch, "Bet is too early/late");
require(_bettable(epoch), "Round not bettable");
require(msg.value >= minBetAmount, "Bet amount must be greater than minBetAmount");
require(ledger[epoch][msg.sender].amount == 0, "Can only bet once per round");
// Update round data
uint256 amount = msg.value;
Round storage round = rounds[epoch];
round.totalAmount = round.totalAmount + amount;
round.bearAmount = round.bearAmount + amount;
// Update user data
BetInfo storage betInfo = ledger[epoch][msg.sender];
betInfo.position = Position.Bear;
betInfo.amount = amount;
userRounds[msg.sender].push(epoch);
emit BetBear(msg.sender, epoch, amount);
}
| 3,485 |
248 | // ========== PUBLIC FUNCTIONS ========== / | function locked__of(address _addr) external view returns (uint256) {
return locked[_addr].amount;
}
| function locked__of(address _addr) external view returns (uint256) {
return locked[_addr].amount;
}
| 23,009 |
0 | // Deposit VAI to VAIVault for XVS allocation _amount The amount to deposit to vault / | function deposit(uint256 _amount) external;
| function deposit(uint256 _amount) external;
| 28,937 |
42 | // Error Codes | enum Errors {
ORDER_EXPIRED, // Order has already expired
ORDER_FULLY_FILLED_OR_CANCELLED, // Order has already been fully filled or cancelled
ROUNDING_ERROR_TOO_LARGE, // Rounding error too large
INSUFFICIENT_BALANCE_OR_ALLOWANCE // Insufficient balance or allowance for token transfer
}
| enum Errors {
ORDER_EXPIRED, // Order has already expired
ORDER_FULLY_FILLED_OR_CANCELLED, // Order has already been fully filled or cancelled
ROUNDING_ERROR_TOO_LARGE, // Rounding error too large
INSUFFICIENT_BALANCE_OR_ALLOWANCE // Insufficient balance or allowance for token transfer
}
| 30,502 |
110 | // curRSalt SAFE, CHECKED | uint256 _seed = getSeed(keyBlockNr) + curRSalt;
uint256 onePercent = grandPot / 100;
| uint256 _seed = getSeed(keyBlockNr) + curRSalt;
uint256 onePercent = grandPot / 100;
| 19,029 |
3 | // mapping user addresses to an array of lockups name for that user | mapping (address => bytes32[]) internal userToLockups;
| mapping (address => bytes32[]) internal userToLockups;
| 54,509 |
68 | // Fill Order Exposes functions to fill an order on the book / | contract FillOrder is Initializable, ReentrancyGuard, IFillOrder {
using SafeERC20 for IERC20;
using SafeMathUint256 for uint256;
using Trade for Trade.Data;
IAugur public augur;
IAugurTrading public augurTrading;
address public zeroXTrade;
address public trade;
Trade.StoredContracts private storedContracts;
mapping (address => uint256[]) public marketOutcomeVolumes;
mapping (address => uint256) public marketTotalTrades;
uint256 private constant MAX_APPROVAL_AMOUNT = 2 ** 256 - 1;
function initialize(IAugur _augur, IAugurTrading _augurTrading) public beforeInitialized {
endInitialization();
augur = _augur;
augurTrading = _augurTrading;
IERC20 _cash = IERC20(augur.lookup("Cash"));
storedContracts = Trade.StoredContracts({
augur: _augur,
augurTrading: _augurTrading,
orders: IOrders(_augurTrading.lookup("Orders")),
denominationToken: _cash,
profitLoss: IProfitLoss(_augurTrading.lookup("ProfitLoss")),
shareToken: IShareToken(_augur.lookup("ShareToken"))
});
require(storedContracts.orders != IOrders(0));
require(storedContracts.profitLoss != IProfitLoss(0));
require(storedContracts.shareToken != IShareToken(0));
trade = _augurTrading.lookup("Trade");
require(trade != address(0));
zeroXTrade = _augurTrading.lookup("ZeroXTrade");
require(zeroXTrade != address(0));
_cash.safeApprove(address(_augur), MAX_APPROVAL_AMOUNT);
}
/**
* @notice Fill an order
* @param _orderId The id of the order to fill
* @param _amountFillerWants The number of attoShares desired
* @param _tradeGroupId A Bytes32 value used when attempting to associate multiple orderbook actions with a single TX
* @param _fingerprint Fingerprint of the filler used to naively restrict affiliate fee dispursement
* @return The amount remaining the filler wants
*/
function publicFillOrder(bytes32 _orderId, uint256 _amountFillerWants, bytes32 _tradeGroupId, bytes32 _fingerprint) external returns (uint256) {
address _filler = msg.sender;
Trade.Data memory _tradeData = Trade.create(storedContracts, _orderId, _filler, _amountFillerWants, _fingerprint);
(uint256 _amountRemaining, uint256 _fees) = fillOrderInternal(_filler, _tradeData, _amountFillerWants, _tradeGroupId);
return _amountRemaining;
}
function fillOrder(address _filler, bytes32 _orderId, uint256 _amountFillerWants, bytes32 _tradeGroupId, bytes32 _fingerprint) external returns (uint256) {
require(msg.sender == trade);
Trade.Data memory _tradeData = Trade.create(storedContracts, _orderId, _filler, _amountFillerWants, _fingerprint);
(uint256 _amountRemaining, uint256 _fees) = fillOrderInternal(_filler, _tradeData, _amountFillerWants, _tradeGroupId);
return _amountRemaining;
}
function fillZeroXOrder(IMarket _market, uint256 _outcome, uint256 _price, Order.Types _orderType, address _creator, uint256 _amount, bytes32 _fingerprint, bytes32 _tradeGroupId, address _filler) external returns (uint256 _amountRemaining, uint256 _fees) {
require(msg.sender == zeroXTrade);
require(augur.isKnownMarket(_market));
Trade.OrderData memory _orderData = Trade.createOrderData(storedContracts.shareToken, _market, _outcome, _price, _orderType, _amount, _creator);
Trade.Data memory _tradeData = Trade.createWithData(storedContracts, _orderData, _filler, _amount, _fingerprint);
return fillOrderInternal(_filler, _tradeData, _amount, _tradeGroupId);
}
function fillOrderInternal(address _filler, Trade.Data memory _tradeData, uint256 _amountFillerWants, bytes32 _tradeGroupId) internal nonReentrant returns (uint256 _amountRemainingFillerWants, uint256 _totalFees) {
uint256 _marketCreatorFees;
uint256 _reporterFees;
(_marketCreatorFees, _reporterFees) = _tradeData.tradeMakerSharesForFillerShares();
_tradeData.tradeMakerTokensForFillerShares();
_tradeData.tradeMakerSharesForFillerTokens();
uint256 _tokensRefunded = _tradeData.tradeMakerTokensForFillerTokens();
sellCompleteSets(_tradeData);
uint256 _amountRemainingFillerWants = _tradeData.filler.sharesToSell.add(_tradeData.filler.sharesToBuy);
uint256 _amountFilled = _amountFillerWants.sub(_amountRemainingFillerWants);
if (_tradeData.order.orderId != bytes32(0)) {
_tradeData.contracts.orders.recordFillOrder(_tradeData.order.orderId, _tradeData.getMakerSharesDepleted(), _tradeData.getMakerTokensDepleted(), _amountFilled);
}
_totalFees = _marketCreatorFees.add(_reporterFees);
if (_tradeData.order.orderId != bytes32(0)) {
logOrderFilled(_tradeData, _tradeData.order.sharePriceLong, _totalFees, _amountFilled, _tradeGroupId);
}
logAndUpdateVolume(_tradeData);
if (_totalFees > 0) {
uint256 _longFees = _totalFees.mul(_tradeData.order.sharePriceLong).div(_tradeData.contracts.market.getNumTicks());
uint256 _shortFees = _totalFees.sub(_longFees);
_tradeData.contracts.profitLoss.adjustTraderProfitForFees(_tradeData.contracts.market, _tradeData.getLongShareBuyerDestination(), _tradeData.order.outcome, _longFees);
_tradeData.contracts.profitLoss.adjustTraderProfitForFees(_tradeData.contracts.market, _tradeData.getShortShareBuyerDestination(), _tradeData.order.outcome, _shortFees);
}
updateProfitLoss(_tradeData, _amountFilled);
if (_tradeData.creator.participantAddress == _tradeData.filler.participantAddress) {
_tradeData.contracts.profitLoss.recordFrozenFundChange(_tradeData.contracts.universe, _tradeData.contracts.market, _tradeData.creator.participantAddress, _tradeData.order.outcome, -int256(_tokensRefunded));
}
return (_amountRemainingFillerWants, _totalFees);
}
function sellCompleteSets(Trade.Data memory _tradeData) internal returns (bool) {
address _filler = _tradeData.filler.participantAddress;
address _creator = _tradeData.creator.participantAddress;
IMarket _market = _tradeData.contracts.market;
uint256 _numOutcomes = _market.getNumberOfOutcomes();
uint256[] memory _outcomes = new uint256[](_numOutcomes);
for (uint256 _i = 0; _i < _numOutcomes; _i++) {
_outcomes[_i] = _i;
}
uint256 _fillerCompleteSets = _tradeData.contracts.shareToken.lowestBalanceOfMarketOutcomes(_market, _outcomes, _filler);
uint256 _creatorCompleteSets = _tradeData.contracts.shareToken.lowestBalanceOfMarketOutcomes(_market, _outcomes, _creator);
if (_fillerCompleteSets > 0) {
_tradeData.contracts.shareToken.sellCompleteSets(_market, _filler, _filler, _fillerCompleteSets, _tradeData.fingerprint);
}
if (_creatorCompleteSets > 0) {
_tradeData.contracts.shareToken.sellCompleteSets(_market, _creator, _creator, _creatorCompleteSets, _tradeData.fingerprint);
}
return true;
}
function logOrderFilled(Trade.Data memory _tradeData, uint256 _price, uint256 _fees, uint256 _amountFilled, bytes32 _tradeGroupId) private returns (bool) {
_tradeData.contracts.augurTrading.logOrderFilled(_tradeData.contracts.universe, _tradeData.creator.participantAddress, _tradeData.filler.participantAddress, _price, _fees, _amountFilled, _tradeData.order.orderId, _tradeGroupId);
return true;
}
function logAndUpdateVolume(Trade.Data memory _tradeData) private {
IMarket _market = _tradeData.contracts.market;
uint256 _makerSharesDepleted = _tradeData.getMakerSharesDepleted();
uint256 _fillerSharesDepleted = _tradeData.getFillerSharesDepleted();
uint256 _makerTokensDepleted = _tradeData.getMakerTokensDepleted();
uint256 _fillerTokensDepleted = _tradeData.getFillerTokensDepleted();
uint256 _completeSetTokens = _makerSharesDepleted.min(_fillerSharesDepleted).mul(_market.getNumTicks());
if (marketOutcomeVolumes[address(_market)].length == 0) {
marketOutcomeVolumes[address(_market)].length = _tradeData.shortOutcomes.length + 1;
}
marketOutcomeVolumes[address(_market)][_tradeData.order.outcome] = marketOutcomeVolumes[address(_market)][_tradeData.order.outcome].add(_makerTokensDepleted).add(_fillerTokensDepleted).add(_completeSetTokens);
uint256[] memory tmpMarketOutcomeVolumes = marketOutcomeVolumes[address(_market)];
uint256 _volume;
for (uint256 i = 0; i < tmpMarketOutcomeVolumes.length; i++) {
_volume += tmpMarketOutcomeVolumes[i];
}
uint256 _totalTrades = marketTotalTrades[address(_market)].add(1);
marketTotalTrades[address(_market)] = _totalTrades;
_tradeData.contracts.augurTrading.logMarketVolumeChanged(_tradeData.contracts.universe, address(_market), _volume, tmpMarketOutcomeVolumes, _totalTrades);
}
function updateProfitLoss(Trade.Data memory _tradeData, uint256 _amountFilled) private returns (bool) {
uint256 makerTokensDepleted = _tradeData.order.orderId != bytes32(0) ? 0 : _tradeData.getMakerTokensDepleted();
uint256 _numLongTokens = _tradeData.creator.direction == Trade.Direction.Long ? makerTokensDepleted : _tradeData.getFillerTokensDepleted();
uint256 _numShortTokens = _tradeData.creator.direction == Trade.Direction.Short ? makerTokensDepleted : _tradeData.getFillerTokensDepleted();
uint256 _numLongShares = _tradeData.creator.direction == Trade.Direction.Long ? _tradeData.getMakerSharesDepleted() : _tradeData.getFillerSharesDepleted();
uint256 _numShortShares = _tradeData.creator.direction == Trade.Direction.Short ? _tradeData.getMakerSharesDepleted() : _tradeData.getFillerSharesDepleted();
_tradeData.contracts.profitLoss.recordTrade(_tradeData.contracts.universe, _tradeData.contracts.market, _tradeData.getLongShareBuyerDestination(), _tradeData.getShortShareBuyerDestination(), _tradeData.order.outcome, int256(_amountFilled), int256(_tradeData.order.sharePriceLong), _numLongTokens, _numShortTokens, _numLongShares, _numShortShares);
return true;
}
function getMarketOutcomeValues(IMarket _market) public view returns (uint256[] memory) {
return marketOutcomeVolumes[address(_market)];
}
function getMarketVolume(IMarket _market) public view returns (uint256) {
uint256[] memory tmpMarketOutcomeVolumes = marketOutcomeVolumes[address(_market)];
uint256 _volume;
for (uint256 i = 0; i < tmpMarketOutcomeVolumes.length; i++) {
_volume += tmpMarketOutcomeVolumes[i];
}
return _volume;
}
}
| contract FillOrder is Initializable, ReentrancyGuard, IFillOrder {
using SafeERC20 for IERC20;
using SafeMathUint256 for uint256;
using Trade for Trade.Data;
IAugur public augur;
IAugurTrading public augurTrading;
address public zeroXTrade;
address public trade;
Trade.StoredContracts private storedContracts;
mapping (address => uint256[]) public marketOutcomeVolumes;
mapping (address => uint256) public marketTotalTrades;
uint256 private constant MAX_APPROVAL_AMOUNT = 2 ** 256 - 1;
function initialize(IAugur _augur, IAugurTrading _augurTrading) public beforeInitialized {
endInitialization();
augur = _augur;
augurTrading = _augurTrading;
IERC20 _cash = IERC20(augur.lookup("Cash"));
storedContracts = Trade.StoredContracts({
augur: _augur,
augurTrading: _augurTrading,
orders: IOrders(_augurTrading.lookup("Orders")),
denominationToken: _cash,
profitLoss: IProfitLoss(_augurTrading.lookup("ProfitLoss")),
shareToken: IShareToken(_augur.lookup("ShareToken"))
});
require(storedContracts.orders != IOrders(0));
require(storedContracts.profitLoss != IProfitLoss(0));
require(storedContracts.shareToken != IShareToken(0));
trade = _augurTrading.lookup("Trade");
require(trade != address(0));
zeroXTrade = _augurTrading.lookup("ZeroXTrade");
require(zeroXTrade != address(0));
_cash.safeApprove(address(_augur), MAX_APPROVAL_AMOUNT);
}
/**
* @notice Fill an order
* @param _orderId The id of the order to fill
* @param _amountFillerWants The number of attoShares desired
* @param _tradeGroupId A Bytes32 value used when attempting to associate multiple orderbook actions with a single TX
* @param _fingerprint Fingerprint of the filler used to naively restrict affiliate fee dispursement
* @return The amount remaining the filler wants
*/
function publicFillOrder(bytes32 _orderId, uint256 _amountFillerWants, bytes32 _tradeGroupId, bytes32 _fingerprint) external returns (uint256) {
address _filler = msg.sender;
Trade.Data memory _tradeData = Trade.create(storedContracts, _orderId, _filler, _amountFillerWants, _fingerprint);
(uint256 _amountRemaining, uint256 _fees) = fillOrderInternal(_filler, _tradeData, _amountFillerWants, _tradeGroupId);
return _amountRemaining;
}
function fillOrder(address _filler, bytes32 _orderId, uint256 _amountFillerWants, bytes32 _tradeGroupId, bytes32 _fingerprint) external returns (uint256) {
require(msg.sender == trade);
Trade.Data memory _tradeData = Trade.create(storedContracts, _orderId, _filler, _amountFillerWants, _fingerprint);
(uint256 _amountRemaining, uint256 _fees) = fillOrderInternal(_filler, _tradeData, _amountFillerWants, _tradeGroupId);
return _amountRemaining;
}
function fillZeroXOrder(IMarket _market, uint256 _outcome, uint256 _price, Order.Types _orderType, address _creator, uint256 _amount, bytes32 _fingerprint, bytes32 _tradeGroupId, address _filler) external returns (uint256 _amountRemaining, uint256 _fees) {
require(msg.sender == zeroXTrade);
require(augur.isKnownMarket(_market));
Trade.OrderData memory _orderData = Trade.createOrderData(storedContracts.shareToken, _market, _outcome, _price, _orderType, _amount, _creator);
Trade.Data memory _tradeData = Trade.createWithData(storedContracts, _orderData, _filler, _amount, _fingerprint);
return fillOrderInternal(_filler, _tradeData, _amount, _tradeGroupId);
}
function fillOrderInternal(address _filler, Trade.Data memory _tradeData, uint256 _amountFillerWants, bytes32 _tradeGroupId) internal nonReentrant returns (uint256 _amountRemainingFillerWants, uint256 _totalFees) {
uint256 _marketCreatorFees;
uint256 _reporterFees;
(_marketCreatorFees, _reporterFees) = _tradeData.tradeMakerSharesForFillerShares();
_tradeData.tradeMakerTokensForFillerShares();
_tradeData.tradeMakerSharesForFillerTokens();
uint256 _tokensRefunded = _tradeData.tradeMakerTokensForFillerTokens();
sellCompleteSets(_tradeData);
uint256 _amountRemainingFillerWants = _tradeData.filler.sharesToSell.add(_tradeData.filler.sharesToBuy);
uint256 _amountFilled = _amountFillerWants.sub(_amountRemainingFillerWants);
if (_tradeData.order.orderId != bytes32(0)) {
_tradeData.contracts.orders.recordFillOrder(_tradeData.order.orderId, _tradeData.getMakerSharesDepleted(), _tradeData.getMakerTokensDepleted(), _amountFilled);
}
_totalFees = _marketCreatorFees.add(_reporterFees);
if (_tradeData.order.orderId != bytes32(0)) {
logOrderFilled(_tradeData, _tradeData.order.sharePriceLong, _totalFees, _amountFilled, _tradeGroupId);
}
logAndUpdateVolume(_tradeData);
if (_totalFees > 0) {
uint256 _longFees = _totalFees.mul(_tradeData.order.sharePriceLong).div(_tradeData.contracts.market.getNumTicks());
uint256 _shortFees = _totalFees.sub(_longFees);
_tradeData.contracts.profitLoss.adjustTraderProfitForFees(_tradeData.contracts.market, _tradeData.getLongShareBuyerDestination(), _tradeData.order.outcome, _longFees);
_tradeData.contracts.profitLoss.adjustTraderProfitForFees(_tradeData.contracts.market, _tradeData.getShortShareBuyerDestination(), _tradeData.order.outcome, _shortFees);
}
updateProfitLoss(_tradeData, _amountFilled);
if (_tradeData.creator.participantAddress == _tradeData.filler.participantAddress) {
_tradeData.contracts.profitLoss.recordFrozenFundChange(_tradeData.contracts.universe, _tradeData.contracts.market, _tradeData.creator.participantAddress, _tradeData.order.outcome, -int256(_tokensRefunded));
}
return (_amountRemainingFillerWants, _totalFees);
}
function sellCompleteSets(Trade.Data memory _tradeData) internal returns (bool) {
address _filler = _tradeData.filler.participantAddress;
address _creator = _tradeData.creator.participantAddress;
IMarket _market = _tradeData.contracts.market;
uint256 _numOutcomes = _market.getNumberOfOutcomes();
uint256[] memory _outcomes = new uint256[](_numOutcomes);
for (uint256 _i = 0; _i < _numOutcomes; _i++) {
_outcomes[_i] = _i;
}
uint256 _fillerCompleteSets = _tradeData.contracts.shareToken.lowestBalanceOfMarketOutcomes(_market, _outcomes, _filler);
uint256 _creatorCompleteSets = _tradeData.contracts.shareToken.lowestBalanceOfMarketOutcomes(_market, _outcomes, _creator);
if (_fillerCompleteSets > 0) {
_tradeData.contracts.shareToken.sellCompleteSets(_market, _filler, _filler, _fillerCompleteSets, _tradeData.fingerprint);
}
if (_creatorCompleteSets > 0) {
_tradeData.contracts.shareToken.sellCompleteSets(_market, _creator, _creator, _creatorCompleteSets, _tradeData.fingerprint);
}
return true;
}
function logOrderFilled(Trade.Data memory _tradeData, uint256 _price, uint256 _fees, uint256 _amountFilled, bytes32 _tradeGroupId) private returns (bool) {
_tradeData.contracts.augurTrading.logOrderFilled(_tradeData.contracts.universe, _tradeData.creator.participantAddress, _tradeData.filler.participantAddress, _price, _fees, _amountFilled, _tradeData.order.orderId, _tradeGroupId);
return true;
}
function logAndUpdateVolume(Trade.Data memory _tradeData) private {
IMarket _market = _tradeData.contracts.market;
uint256 _makerSharesDepleted = _tradeData.getMakerSharesDepleted();
uint256 _fillerSharesDepleted = _tradeData.getFillerSharesDepleted();
uint256 _makerTokensDepleted = _tradeData.getMakerTokensDepleted();
uint256 _fillerTokensDepleted = _tradeData.getFillerTokensDepleted();
uint256 _completeSetTokens = _makerSharesDepleted.min(_fillerSharesDepleted).mul(_market.getNumTicks());
if (marketOutcomeVolumes[address(_market)].length == 0) {
marketOutcomeVolumes[address(_market)].length = _tradeData.shortOutcomes.length + 1;
}
marketOutcomeVolumes[address(_market)][_tradeData.order.outcome] = marketOutcomeVolumes[address(_market)][_tradeData.order.outcome].add(_makerTokensDepleted).add(_fillerTokensDepleted).add(_completeSetTokens);
uint256[] memory tmpMarketOutcomeVolumes = marketOutcomeVolumes[address(_market)];
uint256 _volume;
for (uint256 i = 0; i < tmpMarketOutcomeVolumes.length; i++) {
_volume += tmpMarketOutcomeVolumes[i];
}
uint256 _totalTrades = marketTotalTrades[address(_market)].add(1);
marketTotalTrades[address(_market)] = _totalTrades;
_tradeData.contracts.augurTrading.logMarketVolumeChanged(_tradeData.contracts.universe, address(_market), _volume, tmpMarketOutcomeVolumes, _totalTrades);
}
function updateProfitLoss(Trade.Data memory _tradeData, uint256 _amountFilled) private returns (bool) {
uint256 makerTokensDepleted = _tradeData.order.orderId != bytes32(0) ? 0 : _tradeData.getMakerTokensDepleted();
uint256 _numLongTokens = _tradeData.creator.direction == Trade.Direction.Long ? makerTokensDepleted : _tradeData.getFillerTokensDepleted();
uint256 _numShortTokens = _tradeData.creator.direction == Trade.Direction.Short ? makerTokensDepleted : _tradeData.getFillerTokensDepleted();
uint256 _numLongShares = _tradeData.creator.direction == Trade.Direction.Long ? _tradeData.getMakerSharesDepleted() : _tradeData.getFillerSharesDepleted();
uint256 _numShortShares = _tradeData.creator.direction == Trade.Direction.Short ? _tradeData.getMakerSharesDepleted() : _tradeData.getFillerSharesDepleted();
_tradeData.contracts.profitLoss.recordTrade(_tradeData.contracts.universe, _tradeData.contracts.market, _tradeData.getLongShareBuyerDestination(), _tradeData.getShortShareBuyerDestination(), _tradeData.order.outcome, int256(_amountFilled), int256(_tradeData.order.sharePriceLong), _numLongTokens, _numShortTokens, _numLongShares, _numShortShares);
return true;
}
function getMarketOutcomeValues(IMarket _market) public view returns (uint256[] memory) {
return marketOutcomeVolumes[address(_market)];
}
function getMarketVolume(IMarket _market) public view returns (uint256) {
uint256[] memory tmpMarketOutcomeVolumes = marketOutcomeVolumes[address(_market)];
uint256 _volume;
for (uint256 i = 0; i < tmpMarketOutcomeVolumes.length; i++) {
_volume += tmpMarketOutcomeVolumes[i];
}
return _volume;
}
}
| 45,872 |
117 | // SteakToken with Governance. | contract SteakToken is ERC20("SteakToken", "STEAK"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegator The address to get delegatee for
*/
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s
)
external
{
bytes32 domainSeparator = keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)
)
);
bytes32 structHash = keccak256(
abi.encode(
DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry
)
);
bytes32 digest = keccak256(
abi.encodePacked(
"\x19\x01",
domainSeparator,
structHash
)
);
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "STEAK::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "STEAK::delegateBySig: invalid nonce");
require(now <= expiry, "STEAK::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "STEAK::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying STEAKs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
)
internal
{
uint32 blockNumber = safe32(block.number, "STEAK::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
} | contract SteakToken is ERC20("SteakToken", "STEAK"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegator The address to get delegatee for
*/
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s
)
external
{
bytes32 domainSeparator = keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)
)
);
bytes32 structHash = keccak256(
abi.encode(
DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry
)
);
bytes32 digest = keccak256(
abi.encodePacked(
"\x19\x01",
domainSeparator,
structHash
)
);
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "STEAK::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "STEAK::delegateBySig: invalid nonce");
require(now <= expiry, "STEAK::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "STEAK::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying STEAKs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
)
internal
{
uint32 blockNumber = safe32(block.number, "STEAK::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
} | 17,741 |
73 | // Returns a token ID at a given `index` of all the tokens stored by the contract.Use along with {totalSupply} to enumerate all tokens. / | function tokenByIndex(uint256 index) external view returns (uint256);
| function tokenByIndex(uint256 index) external view returns (uint256);
| 856 |
1 | // Staking period timestamp (Debatable on timestamp vs blocknumber - went with timestamp) | struct StakePeriod {
uint256 startPeriod;
uint256 submissionEndPeriod;
uint256 endPeriod;
uint256 maxStake;
uint256 windowRewardAmount;
uint256 windowMaxAmount;
}
| struct StakePeriod {
uint256 startPeriod;
uint256 submissionEndPeriod;
uint256 endPeriod;
uint256 maxStake;
uint256 windowRewardAmount;
uint256 windowMaxAmount;
}
| 40,291 |
196 | // Emitted by Ownable when ownership is transferred./previousOwner The previous owner of the contract./newOwner The new owner of the contract. | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
| event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
| 14,953 |
141 | // Extracts the outpoint tx id from an input/32-byte tx id/_inputThe input/ returnThe tx id (little-endian bytes) | function extractInputTxIdLE(bytes memory _input) internal pure returns (bytes32) {
return _input.slice(0, 32).toBytes32();
}
| function extractInputTxIdLE(bytes memory _input) internal pure returns (bytes32) {
return _input.slice(0, 32).toBytes32();
}
| 31,577 |
19 | // Mint token ID 0 / don't allow any user mints | _setupNewToken(newContractURI, 0);
| _setupNewToken(newContractURI, 0);
| 6,333 |
35 | // 0 Means "No Cap" | if (activeCollateralUSDCap == 0) {
return uint(Error.NO_ERROR);
}
| if (activeCollateralUSDCap == 0) {
return uint(Error.NO_ERROR);
}
| 26,229 |
4 | // Interest rate model | InterestModel public interestModel;
| InterestModel public interestModel;
| 23,525 |
74 | // 1 byte for the length prefix | require(item.len == 21);
return address(toUint(item));
| require(item.len == 21);
return address(toUint(item));
| 30,925 |
2 | // Init V3 | registrar.init(ZMM);
ZPFS.init(address(ZMM), address(0));
| registrar.init(ZMM);
ZPFS.init(address(ZMM), address(0));
| 43,786 |
336 | // burn tokens. Can only be called by token owner or approved address.On burn, calls back to the registered manager's onBurn method / | function burn(
| function burn(
| 74,255 |
1 | // mytestcontractCreature - a contract for my non-fungible creatures. / | contract mytestcontract is ERC721Tradable {
constructor (string memory name, string memory symbol, address _proxyRegistryAddress)
ERC721Tradable(name, symbol, _proxyRegistryAddress)
{}
function baseTokenURI() public virtual pure override returns (string memory) {
return "https://4e63jvjk6fhvmbw5fvvek7nc3pdpzu5eeng6yurlcibidiugdvlq.arweave.net/4T201SrxT1YG3S1qRX2i28b806QjTexSKxICgaKGHVc";
}
} | contract mytestcontract is ERC721Tradable {
constructor (string memory name, string memory symbol, address _proxyRegistryAddress)
ERC721Tradable(name, symbol, _proxyRegistryAddress)
{}
function baseTokenURI() public virtual pure override returns (string memory) {
return "https://4e63jvjk6fhvmbw5fvvek7nc3pdpzu5eeng6yurlcibidiugdvlq.arweave.net/4T201SrxT1YG3S1qRX2i28b806QjTexSKxICgaKGHVc";
}
} | 9,822 |
7 | // import files from common directory | import { TokenInterface , MemoryInterface } from "../common/interfaces.sol";
import { Stores } from "../common/stores.sol";
import { DSMath } from "../common/math.sol";
interface SoloMarginContract {
struct Info {
address owner;
uint256 number;
}
enum ActionType {
Deposit,
Withdraw,
Transfer,
Buy,
Sell,
Trade,
Liquidate,
Vaporize,
Call
}
enum AssetDenomination {
Wei,
Par
}
enum AssetReference {
Delta,
Target
}
struct AssetAmount {
bool sign;
AssetDenomination denomination;
AssetReference ref;
uint256 value;
}
struct ActionArgs {
ActionType actionType;
uint256 accountId;
AssetAmount amount;
uint256 primaryMarketId;
uint256 secondaryMarketId;
address otherAddress;
uint256 otherAccountId;
bytes data;
}
struct Wei {
bool sign;
uint256 value;
}
function operate(Info[] calldata accounts, ActionArgs[] calldata actions) external;
function getAccountWei(Info calldata account, uint256 marketId) external returns (Wei memory);
function getNumMarkets() external view returns (uint256);
function getMarketTokenAddress(uint256 marketId) external view returns (address);
}
| import { TokenInterface , MemoryInterface } from "../common/interfaces.sol";
import { Stores } from "../common/stores.sol";
import { DSMath } from "../common/math.sol";
interface SoloMarginContract {
struct Info {
address owner;
uint256 number;
}
enum ActionType {
Deposit,
Withdraw,
Transfer,
Buy,
Sell,
Trade,
Liquidate,
Vaporize,
Call
}
enum AssetDenomination {
Wei,
Par
}
enum AssetReference {
Delta,
Target
}
struct AssetAmount {
bool sign;
AssetDenomination denomination;
AssetReference ref;
uint256 value;
}
struct ActionArgs {
ActionType actionType;
uint256 accountId;
AssetAmount amount;
uint256 primaryMarketId;
uint256 secondaryMarketId;
address otherAddress;
uint256 otherAccountId;
bytes data;
}
struct Wei {
bool sign;
uint256 value;
}
function operate(Info[] calldata accounts, ActionArgs[] calldata actions) external;
function getAccountWei(Info calldata account, uint256 marketId) external returns (Wei memory);
function getNumMarkets() external view returns (uint256);
function getMarketTokenAddress(uint256 marketId) external view returns (address);
}
| 1,755 |
873 | // (timeSinceLastClaimINTERNAL_TOKEN_PRECISION) / YEAR | uint256 proRataYears =
timeSinceLastClaim.mul(uint256(Constants.INTERNAL_TOKEN_PRECISION)).div(Constants.YEAR);
return proRataYears.mul(emissionRatePerYear);
| uint256 proRataYears =
timeSinceLastClaim.mul(uint256(Constants.INTERNAL_TOKEN_PRECISION)).div(Constants.YEAR);
return proRataYears.mul(emissionRatePerYear);
| 65,228 |
41 | // Policy Hooks // Checks if the account should be allowed to mint tokens in the given market slToken The market to verify the mint against minter The account which would get the minted tokens mintAmount The amount of underlying being supplied to the market in exchange for tokensreturn 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) / | function mintAllowed(address slToken, address minter, uint mintAmount) external returns (uint) {
// Pausing is a very serious situation - we revert to sound the alarms
require(!mintGuardianPaused[slToken], "mint is paused");
// Shh - currently unused
minter;
mintAmount;
if (!markets[slToken].isListed) {
return uint(Error.MARKET_NOT_LISTED);
}
// Keep the flywheel moving
updateSashimiSupplyIndex(slToken);
distributeSupplierSashimi(slToken, minter, false);
return uint(Error.NO_ERROR);
}
| function mintAllowed(address slToken, address minter, uint mintAmount) external returns (uint) {
// Pausing is a very serious situation - we revert to sound the alarms
require(!mintGuardianPaused[slToken], "mint is paused");
// Shh - currently unused
minter;
mintAmount;
if (!markets[slToken].isListed) {
return uint(Error.MARKET_NOT_LISTED);
}
// Keep the flywheel moving
updateSashimiSupplyIndex(slToken);
distributeSupplierSashimi(slToken, minter, false);
return uint(Error.NO_ERROR);
}
| 7,502 |
1 | // set up permissions | _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
| _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
| 29,754 |
104 | // This allows you to buy tokens by sending Ether directly to the smart contract without including any transaction data (useful for, say, mobile wallet apps). | function () payable public {
// msg.value is the amount of Ether sent by the transaction.
if (msg.value > 0) {
fund();
} else {
withdrawOld(msg.sender);
}
}
| function () payable public {
// msg.value is the amount of Ether sent by the transaction.
if (msg.value > 0) {
fund();
} else {
withdrawOld(msg.sender);
}
}
| 10,178 |
7 | // The address of the Governor Guardian | address public guardian;
| address public guardian;
| 14,699 |
149 | // loop through every element in bytes32 | for (uint256 _bytesCounter = 0; _bytesCounter < 32; _bytesCounter++) {
bytes1 _char = bytes1(bytes32(uint256(_data) * 2 ** (8 * _bytesCounter)));
if (_char != 0) {
_bytesContainer[_charCount] = _char;
_charCount++;
}
| for (uint256 _bytesCounter = 0; _bytesCounter < 32; _bytesCounter++) {
bytes1 _char = bytes1(bytes32(uint256(_data) * 2 ** (8 * _bytesCounter)));
if (_char != 0) {
_bytesContainer[_charCount] = _char;
_charCount++;
}
| 33,835 |
19 | // Execution of antiwhale./ | function limitAmount(uint256 _rId, uint256 _sId)
private
returns(uint256)
| function limitAmount(uint256 _rId, uint256 _sId)
private
returns(uint256)
| 21,607 |
22 | // returns PolicyBook reward per block multiplied by 1025 | function getPolicyBookRewardPerBlock(address policyBookAddress)
external
view
override
returns (uint256)
| function getPolicyBookRewardPerBlock(address policyBookAddress)
external
view
override
returns (uint256)
| 51,835 |
5 | // Get the chain ID of the current chain | function chainId() external view returns (uint16);
| function chainId() external view returns (uint16);
| 18,695 |
44 | // getBattleStatereturn current state string of the game to web app / | function getBattleState() external view returns (string memory) {
if (battleState == BATTLE_STATE.STANDBY) {
return 'STANDBY';
}
if (battleState == BATTLE_STATE.RUNNING) {
return 'RUNNING';
}
if (battleState == BATTLE_STATE.ENDED) {
return 'ENDED';
}
}
| function getBattleState() external view returns (string memory) {
if (battleState == BATTLE_STATE.STANDBY) {
return 'STANDBY';
}
if (battleState == BATTLE_STATE.RUNNING) {
return 'RUNNING';
}
if (battleState == BATTLE_STATE.ENDED) {
return 'ENDED';
}
}
| 20,326 |
313 | // Validate adapter | require(_join.vat() == vat, "IlkRegistry/invalid-join-adapter-vat");
require(vat.wards(address(_join)) == 1, "IlkRegistry/adapter-not-authorized");
| require(_join.vat() == vat, "IlkRegistry/invalid-join-adapter-vat");
require(vat.wards(address(_join)) == 1, "IlkRegistry/adapter-not-authorized");
| 7,963 |
44 | // obtains the information about if this token in unique | bool is_unique = token_unique[token_hash].unique;
| bool is_unique = token_unique[token_hash].unique;
| 11,454 |
68 | // function cancelIco() | onlyTrivial() {
currentState = State.IcoCancelled;
IcoCancelled();
}
| onlyTrivial() {
currentState = State.IcoCancelled;
IcoCancelled();
}
| 53,831 |
23 | // ZCVestingUsed to hold tokens and release once configured amount has been released to consumers. 10% of initial tokens in contract can be claimed for every 15 million tokens that are distributed to consumers.After 150 million tokens are distributed consumer the full balanceof the vesting contract is transferable. (c) Philip Louw / Zero Carbon Project 2018. The MIT Licence. / | contract ZCVesting {
using SafeMath for uint256;
// Total amount of tokens released
uint256 public releasedAmount = 0;
// Address of the Token
ERC20Basic public token;
// Address of the Distribution Contract
IZCDistribution public dist;
// Release to Address
address public releaseAddress;
// Every amount of tokens to release funds
uint256 internal constant STEP_DIST_TOKENS = 15000000 * (10**18);
// Max amount of tokens before all is released
uint256 internal constant MAX_DIST_TOKENS = 150000000 * (10**18);
/**
* @param _tokenAddr The Address of the Token
* @param _distAddr The Address of the Distribution contract
* @param _releaseAddr The Address where to release funds to
*/
constructor(ERC20Basic _tokenAddr, IZCDistribution _distAddr, address _releaseAddr) public {
token = _tokenAddr;
dist = _distAddr;
releaseAddress = _releaseAddr;
}
/**
* @dev Event when Tokens are released
* @param releaseAmount Amount of tokens released
*/
event TokenReleased(uint256 releaseAmount);
/**
* @dev Releases the current allowed amount to the releaseAddress. Returns the amount released
*/
function release() public returns (uint256) {
uint256 distAmount = dist.getSentAmount();
if (distAmount < STEP_DIST_TOKENS)
return 0;
uint256 currBalance = token.balanceOf(address(this));
if (distAmount >= MAX_DIST_TOKENS) {
assert(token.transfer(releaseAddress, currBalance));
releasedAmount = releasedAmount.add(currBalance);
return currBalance;
}
uint256 releaseAllowed = currBalance.add(releasedAmount).div(10).mul(distAmount.div(STEP_DIST_TOKENS));
if (releaseAllowed <= releasedAmount)
return 0;
uint256 releaseAmount = releaseAllowed.sub(releasedAmount);
releasedAmount = releasedAmount.add(releaseAmount);
assert(token.transfer(releaseAddress, releaseAmount));
emit TokenReleased(releaseAmount);
return releaseAmount;
}
/**
* @dev Returns the token balance of this ZCVesting contract
*/
function currentBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
} | contract ZCVesting {
using SafeMath for uint256;
// Total amount of tokens released
uint256 public releasedAmount = 0;
// Address of the Token
ERC20Basic public token;
// Address of the Distribution Contract
IZCDistribution public dist;
// Release to Address
address public releaseAddress;
// Every amount of tokens to release funds
uint256 internal constant STEP_DIST_TOKENS = 15000000 * (10**18);
// Max amount of tokens before all is released
uint256 internal constant MAX_DIST_TOKENS = 150000000 * (10**18);
/**
* @param _tokenAddr The Address of the Token
* @param _distAddr The Address of the Distribution contract
* @param _releaseAddr The Address where to release funds to
*/
constructor(ERC20Basic _tokenAddr, IZCDistribution _distAddr, address _releaseAddr) public {
token = _tokenAddr;
dist = _distAddr;
releaseAddress = _releaseAddr;
}
/**
* @dev Event when Tokens are released
* @param releaseAmount Amount of tokens released
*/
event TokenReleased(uint256 releaseAmount);
/**
* @dev Releases the current allowed amount to the releaseAddress. Returns the amount released
*/
function release() public returns (uint256) {
uint256 distAmount = dist.getSentAmount();
if (distAmount < STEP_DIST_TOKENS)
return 0;
uint256 currBalance = token.balanceOf(address(this));
if (distAmount >= MAX_DIST_TOKENS) {
assert(token.transfer(releaseAddress, currBalance));
releasedAmount = releasedAmount.add(currBalance);
return currBalance;
}
uint256 releaseAllowed = currBalance.add(releasedAmount).div(10).mul(distAmount.div(STEP_DIST_TOKENS));
if (releaseAllowed <= releasedAmount)
return 0;
uint256 releaseAmount = releaseAllowed.sub(releasedAmount);
releasedAmount = releasedAmount.add(releaseAmount);
assert(token.transfer(releaseAddress, releaseAmount));
emit TokenReleased(releaseAmount);
return releaseAmount;
}
/**
* @dev Returns the token balance of this ZCVesting contract
*/
function currentBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
} | 17,192 |
129 | // reverse-for-loops with unsigned integer/ solium-disable-next-line security/no-modify-for-iter-var / find the last non-zero byte in order to determine the length | if (result[i] != 0) {
uint256 length = i + 1;
| if (result[i] != 0) {
uint256 length = i + 1;
| 4,631 |
713 | // Checks if voting of a claim should be closed or not.Internally called by checkVoteClosing methodfor Claims whose status number is 0 or status number lie between 2 and 6. claimId Claim Id. status Current status of claim.return close 1 if voting should be closed,0 in case voting should not be closed,-1 if voting has already been closed. / | function _checkVoteClosingFinal(uint claimId, uint status) internal view returns(int8 close) {
close = 0;
uint coverId;
(, coverId) = cd.getClaimCoverId(claimId);
bytes4 curr = qd.getCurrencyOfCover(coverId);
uint tokenx1e18 = m1.calculateTokenPrice(curr);
uint accept;
uint deny;
(, accept, deny) = cd.getClaimsTokenCA(claimId);
uint caTokens = ((accept.add(deny)).mul(tokenx1e18)).div(DECIMAL1E18);
(, accept, deny) = cd.getClaimsTokenMV(claimId);
uint mvTokens = ((accept.add(deny)).mul(tokenx1e18)).div(DECIMAL1E18);
uint sumassured = qd.getCoverSumAssured(coverId).mul(DECIMAL1E18);
if (status == 0 && caTokens >= sumassured.mul(10)) {
close = 1;
} else if (status >= 1 && status <= 5 && mvTokens >= sumassured.mul(10)) {
close = 1;
}
}
| function _checkVoteClosingFinal(uint claimId, uint status) internal view returns(int8 close) {
close = 0;
uint coverId;
(, coverId) = cd.getClaimCoverId(claimId);
bytes4 curr = qd.getCurrencyOfCover(coverId);
uint tokenx1e18 = m1.calculateTokenPrice(curr);
uint accept;
uint deny;
(, accept, deny) = cd.getClaimsTokenCA(claimId);
uint caTokens = ((accept.add(deny)).mul(tokenx1e18)).div(DECIMAL1E18);
(, accept, deny) = cd.getClaimsTokenMV(claimId);
uint mvTokens = ((accept.add(deny)).mul(tokenx1e18)).div(DECIMAL1E18);
uint sumassured = qd.getCoverSumAssured(coverId).mul(DECIMAL1E18);
if (status == 0 && caTokens >= sumassured.mul(10)) {
close = 1;
} else if (status >= 1 && status <= 5 && mvTokens >= sumassured.mul(10)) {
close = 1;
}
}
| 22,551 |
19 | // how to calculate doubleUnit:specify how much percent increase you want per yeare.g. 130% -> 2.3 multiplier every yearnow divide (1 years) by LOG(2.3) where LOG is the natural logarithm (not LOG10) in this case LOG(2.3) is 0.83290912293 hence multiplying by 1/0.83290912293 is the same31536000 = 1 years (to prevent deprecated warning in solc) | uint256 doubleUnit = (31536000) * 1.2;
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
constructor()
public
onlyOwner()
| uint256 doubleUnit = (31536000) * 1.2;
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
constructor()
public
onlyOwner()
| 68,726 |
56 | // Showsnumber of tokens available for PRE-ICO | uint256 public availablePreICO;
| uint256 public availablePreICO;
| 60,263 |
34 | // Get number of blocks to multiply by | uint256 multiplier = latestRewardBlock - pool.lastRewardBlock;
| uint256 multiplier = latestRewardBlock - pool.lastRewardBlock;
| 21,826 |
19 | // Data kept in EVM-storage for every Request posted to the Witnet Request Board. | struct Request {
IWitnetRequest addr; // The contract containing the Data Request which execution has been requested.
address requester; // Address from which the request was posted.
bytes32 hash; // Hash of the Data Request whose execution has been requested.
uint256 gasprice; // Minimum gas price the DR resolver should pay on the solving tx.
uint256 reward; // Escrowed reward to be paid to the DR resolver.
}
| struct Request {
IWitnetRequest addr; // The contract containing the Data Request which execution has been requested.
address requester; // Address from which the request was posted.
bytes32 hash; // Hash of the Data Request whose execution has been requested.
uint256 gasprice; // Minimum gas price the DR resolver should pay on the solving tx.
uint256 reward; // Escrowed reward to be paid to the DR resolver.
}
| 17,997 |
215 | // Cannot redeem collateral/collateralToken Collateral token used to redeem./newTotalCollateral New total collateral, which is lower than minimum collateral./minimumCollateral Minimum collateral required to complete redeem | error TotalCollateralCannotBeLowerThanMinCollateral(
IERC20 collateralToken, uint256 newTotalCollateral, uint256 minimumCollateral
);
| error TotalCollateralCannotBeLowerThanMinCollateral(
IERC20 collateralToken, uint256 newTotalCollateral, uint256 minimumCollateral
);
| 9,603 |
20 | // Update the user | user.total = total;
updateDebt(addr, poolId);
| user.total = total;
updateDebt(addr, poolId);
| 16,874 |
25 | // monthlyAllocation(lastDepositTime,stakeTime[_stakeholder],percentageShare,time_mins);monthlyAllocation(time_days, stakeTime[_stakeholder], percentageShare, time_mins); return SafeMath.div(rewards[_stakeholder], 100); | return time_days;
| return time_days;
| 6,754 |
16 | // LP token given to LPs of a specific L1 token. | address lpToken;
| address lpToken;
| 33,413 |
229 | // _hatchingMultiplierCoolDown base birthing / | function setHatchingMultiplierCoolDown(uint256 _hatchingMultiplierCoolDown)
external
onlyOwner
| function setHatchingMultiplierCoolDown(uint256 _hatchingMultiplierCoolDown)
external
onlyOwner
| 70,553 |
4 | // Number of unique hashes submitted | uint256 public nSubmittedHashes = 0;
uint256 public nInvalidatedHashes = 0;
| uint256 public nSubmittedHashes = 0;
uint256 public nInvalidatedHashes = 0;
| 15,340 |
44 | // require(debtTx.baseTx.status == TxStatus.Locked, "Status is not locked"); | require(debtTx.baseTx.status == status, "Status is not locked");
require(now < debtTx.baseTx.beginLockedTime.add(debtTx.baseTx.lockedTime), "Redeem timeout");
debtTx.baseTx.status = TxStatus.Redeemed;
return xHash;
| require(debtTx.baseTx.status == status, "Status is not locked");
require(now < debtTx.baseTx.beginLockedTime.add(debtTx.baseTx.lockedTime), "Redeem timeout");
debtTx.baseTx.status = TxStatus.Redeemed;
return xHash;
| 66,124 |
123 | // We usually don't need tend, but if there are positions that need active maintainence, overriding this function is how you would signal for that. | return false;
| return false;
| 1,489 |
106 | // Computes the price and transfers winnings./ Does NOT transfer ownership of token. | function _bid(uint256 _tokenId, uint256 _bidAmount)
internal
returns (uint256)
{
| function _bid(uint256 _tokenId, uint256 _bidAmount)
internal
returns (uint256)
{
| 16,167 |
201 | // Return this in acceptRelayedCall to impede execution of a relayed call. No fees will be charged. / | function _rejectRelayedCall(uint256 errorCode) internal pure returns (uint256, bytes memory) {
return (_RELAYED_CALL_REJECTED + errorCode, "");
}
| function _rejectRelayedCall(uint256 errorCode) internal pure returns (uint256, bytes memory) {
return (_RELAYED_CALL_REJECTED + errorCode, "");
}
| 5,487 |
505 | // _oracle address of chainlink data provider/_jobid job id/_fee maximum fee paid to chainlink data provider/_currentMonth current month's inflation data/_previousMonth previous month's inflation data | constructor(
address _oracle,
bytes32 _jobid,
uint256 _fee,
uint128 _currentMonth,
uint128 _previousMonth
| constructor(
address _oracle,
bytes32 _jobid,
uint256 _fee,
uint128 _currentMonth,
uint128 _previousMonth
| 59,488 |
1 | // Deposit tokens. _token The deposited token address. _amount The amount to deposit. / | function deposit(address _token, uint256 _amount) external nonReentrant whenNotPaused onlyOwner {
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
emit Deposited(msg.sender, _token, _amount);
}
| function deposit(address _token, uint256 _amount) external nonReentrant whenNotPaused onlyOwner {
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
emit Deposited(msg.sender, _token, _amount);
}
| 5,203 |
36 | // Current Token to csToken exchange rate. | uint256 public exchangeRate;
| uint256 public exchangeRate;
| 34,044 |
75 | // Get a CalldataPointer from Order.obj The Order object. return ptr The CalldataPointer. / | function toCalldataPointer(
Order calldata obj
| function toCalldataPointer(
Order calldata obj
| 20,135 |
2 | // The multiplier of utilization rate that gives the slope of the interest rate / | uint public multiplierPerBlock;
| uint public multiplierPerBlock;
| 21,918 |
105 | // - Releases a set of teams if the contest has passed its endingtime (or has been canceled). This method can be called by the general/ public, but should called by our scoring oracle automatically./_contestId - The ID of the contest the teams belong to/_teamIds - TeamIds of the teams we want to release. Array should/ be short enough in length so as not to run out of gas | function releaseTeams(uint32 _contestId, uint32[] _teamIds) public {
require((_contestId < contests.length) && (_contestId > 0));
Contest storage c = contests[_contestId];
// Teams can only be released for canceled contests or contests that have
// passed their end times.
require ((c.status == ContestStatus.Canceled) || (c.endTime <= uint64(now)));
for (uint32 i = 0; i < _teamIds.length; i++) {
uint32 teamId = _teamIds[i];
uint32 teamContestId = teamIdToContestId[teamId];
if (teamContestId == _contestId) {
address owner;
int32 score;
uint32 place;
bool holdsEntryFee;
bool ownsPlayerTokens;
(owner, score, place, holdsEntryFee, ownsPlayerTokens) = teamContract.getTeam(teamId);
if ((c.status == ContestStatus.Canceled) && holdsEntryFee) {
teamContract.refunded(teamId);
if (c.entryFee > 0) {
emit ContestTeamRefundPaid(_contestId, teamId, c.entryFee);
_authorizePayment(owner, c.entryFee);
}
}
if (ownsPlayerTokens) {
teamContract.releaseTeam(teamId);
}
}
}
}
| function releaseTeams(uint32 _contestId, uint32[] _teamIds) public {
require((_contestId < contests.length) && (_contestId > 0));
Contest storage c = contests[_contestId];
// Teams can only be released for canceled contests or contests that have
// passed their end times.
require ((c.status == ContestStatus.Canceled) || (c.endTime <= uint64(now)));
for (uint32 i = 0; i < _teamIds.length; i++) {
uint32 teamId = _teamIds[i];
uint32 teamContestId = teamIdToContestId[teamId];
if (teamContestId == _contestId) {
address owner;
int32 score;
uint32 place;
bool holdsEntryFee;
bool ownsPlayerTokens;
(owner, score, place, holdsEntryFee, ownsPlayerTokens) = teamContract.getTeam(teamId);
if ((c.status == ContestStatus.Canceled) && holdsEntryFee) {
teamContract.refunded(teamId);
if (c.entryFee > 0) {
emit ContestTeamRefundPaid(_contestId, teamId, c.entryFee);
_authorizePayment(owner, c.entryFee);
}
}
if (ownsPlayerTokens) {
teamContract.releaseTeam(teamId);
}
}
}
}
| 17,905 |
365 | // Time elapsed before auction reset [seconds] | uint256 maxAuctionDuration;
| uint256 maxAuctionDuration;
| 43,535 |
6 | // pay out last winner | if (lastPayoutBlock < currentBlock) {
payOut(currWinner);
| if (lastPayoutBlock < currentBlock) {
payOut(currWinner);
| 5,573 |
36 | // Returns the NFT details | function getNFT(
uint256 nftId
| function getNFT(
uint256 nftId
| 11,540 |
0 | // This modifier requires a certain fee being associated with a function call. If the caller sent too much, he or she is refunded, but only after the function body. This was dangerous before Solidity version 0.4.0, where it was possible to skip the part after `_;`. | modifier costs(uint _amount) {
require(msg.value >= _amount);
_;
if (msg.value > _amount)
msg.sender.transfer(msg.value - _amount);
}
| modifier costs(uint _amount) {
require(msg.value >= _amount);
_;
if (msg.value > _amount)
msg.sender.transfer(msg.value - _amount);
}
| 48,253 |
169 | // - Superblock status | enum Status { Unitialized, New, InBattle, SemiApproved, Approved, Invalid }
| enum Status { Unitialized, New, InBattle, SemiApproved, Approved, Invalid }
| 3,054 |
80 | // Emitted when user claim pending rewards/_owner The owner of the pool share./_recipient The address of recipient who will receive the rewards./_token The token claimed/_amount The amount of pending rewards claimed. | event Claim(address indexed _owner, address indexed _recipient, address indexed _token, uint256 _amount);
| event Claim(address indexed _owner, address indexed _recipient, address indexed _token, uint256 _amount);
| 12,311 |
18 | // The remaining unclaimed tokens from a particular auction in a particular era. | mapping(uint => mapping(uint => uint)) public mapEraAuction_EmissionRemaining;
| mapping(uint => mapping(uint => uint)) public mapEraAuction_EmissionRemaining;
| 40,780 |
27 | // Calculates a signature over provided digest by the keep./Only one signing process can be in progress at a time./_digest Digest to be signed. | function sign(bytes32 _digest) external onlyOwner onlyWhenActive {
require(publicKey.length != 0, "Public key was not set yet");
require(!isSigningInProgress(), "Signer is busy");
/* solium-disable-next-line */
signingStartTimestamp = block.timestamp;
digests[_digest] = block.number;
digest = _digest;
emit SignatureRequested(_digest);
}
| function sign(bytes32 _digest) external onlyOwner onlyWhenActive {
require(publicKey.length != 0, "Public key was not set yet");
require(!isSigningInProgress(), "Signer is busy");
/* solium-disable-next-line */
signingStartTimestamp = block.timestamp;
digests[_digest] = block.number;
digest = _digest;
emit SignatureRequested(_digest);
}
| 37,965 |
0 | // address of the the contract with vault parameters | VaultParameters public vaultParameters;
| VaultParameters public vaultParameters;
| 3,277 |
19 | // Agreement account state updated event agreementClass Contract address of the agreement account Account of the agrement state Agreement state of the account / | event AgreementAccountStateUpdated(
| event AgreementAccountStateUpdated(
| 21,751 |
2 | // Initializes the contract setting the deployer as the initial governance. / | constructor(address governance_) {
if (governance_ == address(0)) revert ZeroAddress();
_governance = governance_;
emit GovernanceChanged(address(0), governance_);
}
| constructor(address governance_) {
if (governance_ == address(0)) revert ZeroAddress();
_governance = governance_;
emit GovernanceChanged(address(0), governance_);
}
| 11,731 |
8 | // Contract which oversees inter-kToken operations / | KineControllerInterface public controller;
| KineControllerInterface public controller;
| 6,689 |
388 | // Allows to get approved using a permit and transfer in the same call/this supposes that the permit is for msg.sender/from current owner/to recipient/tokenId the token id/_data optional data to add/deadline the deadline for the permit to be used/signature of permit | function safeTransferFromWithPermit(
address from,
address to,
uint256 tokenId,
bytes memory _data,
uint256 deadline,
bytes memory signature
| function safeTransferFromWithPermit(
address from,
address to,
uint256 tokenId,
bytes memory _data,
uint256 deadline,
bytes memory signature
| 44,420 |
2 | // structures | struct AccountData
| struct AccountData
| 5,545 |
112 | // Reverts if the request is already pending requestId The request ID for fulfillment / | modifier notPendingRequest(
bytes32 requestId
)
| modifier notPendingRequest(
bytes32 requestId
)
| 14,555 |
201 | // We must query this separately, since the wstETH contract doesn't return how much wstETH is minted. | uint256 result = _wstETH.getWstETHByStETH(amount);
| uint256 result = _wstETH.getWstETHByStETH(amount);
| 52,867 |
24 | // time stamp of the starting time of the ico, must return 0 if it depends on the block number/Start time (as required by Eidoo's ICOEngineInterface)/ return Block (Unix) timestamp of mainsale start time | function startTime() public view returns (uint) {
return openingTime;
}
| function startTime() public view returns (uint) {
return openingTime;
}
| 46,220 |
21 | // Internal function for reducing onlyIfUpgradeabilityOwner modifier bytecode overhead. / | function _onlyIfUpgradeabilityOwner() internal view {
require(msg.sender == IUpgradeabilityOwnerStorage(address(this)).upgradeabilityOwner());
}
| function _onlyIfUpgradeabilityOwner() internal view {
require(msg.sender == IUpgradeabilityOwnerStorage(address(this)).upgradeabilityOwner());
}
| 16,501 |
569 | // Claims all rewards from a pool and then withdraws all staked tokens.//_poolId the pool to exit from. | function exit(uint256 _poolId) external nonReentrant {
Pool.Data storage _pool = _pools.get(_poolId);
_pool.update(_ctx);
Stake.Data storage _stake = _stakes[msg.sender][_poolId];
_stake.update(_pool, _ctx);
_claim(_poolId);
_withdraw(_poolId, _stake.totalDeposited);
}
| function exit(uint256 _poolId) external nonReentrant {
Pool.Data storage _pool = _pools.get(_poolId);
_pool.update(_ctx);
Stake.Data storage _stake = _stakes[msg.sender][_poolId];
_stake.update(_pool, _ctx);
_claim(_poolId);
_withdraw(_poolId, _stake.totalDeposited);
}
| 53,707 |
142 | // ---- Function that adds pending rewards, called by the CORE token. ---- | uint256 private coreBalance;
| uint256 private coreBalance;
| 29,423 |
93 | // Remove all fees | function removeAllFee() private {
if(_TotalFee == 0 && _buyFee == 0 && _sellFee == 0) return;
_previousBuyFee = _buyFee;
_previousSellFee = _sellFee;
_previousTotalFee = _TotalFee;
_buyFee = 0;
_sellFee = 0;
_TotalFee = 0;
}
| function removeAllFee() private {
if(_TotalFee == 0 && _buyFee == 0 && _sellFee == 0) return;
_previousBuyFee = _buyFee;
_previousSellFee = _sellFee;
_previousTotalFee = _TotalFee;
_buyFee = 0;
_sellFee = 0;
_TotalFee = 0;
}
| 29,430 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.