file_name
stringlengths 71
779k
| comments
stringlengths 20
182k
| code_string
stringlengths 20
36.9M
| __index_level_0__
int64 0
17.2M
| input_ids
list | attention_mask
list | labels
list |
|---|---|---|---|---|---|---|
./full_match/5/0xa837661FC681c8bfc0251C1DabA951297EfD4075/sources/contracts/guild-core/GuildBank.sol | create the rental deposit the asset and increase the total deposit count | function _deposit(
address _depositor,
address _collection,
uint256 _tokenId,
uint32 _share,
uint64 _duration,
uint32 _amount
) internal returns (uint256 rentalId) {
bool isERC721 = _getCollectionType(_collection);
if (isERC721 && _amount != 1) revert InvalidAmount();
if (!isERC721 && _amount == 0) revert InvalidAmount();
if (_duration == 0) revert InvalidDuration();
if (_share >= MAX_SHARE) revert InvalidShare();
rentalId = s.currentRentalId;
s.rentals[rentalId] = Rental(
_collection,
_tokenId,
_depositor,
address(0),
_share,
_duration,
0,
_amount,
false
);
s.ownerRentalIds[_depositor].add(rentalId);
++s.currentRentalId;
if (isERC721) {
s.totalDeposits[_collection][0] += _amount;
IERC721(_collection).safeTransferFrom(_depositor, address(this), _tokenId);
s.totalDeposits[_collection][_tokenId] += _amount;
IERC1155(_collection).safeTransferFrom(_depositor, address(this), _tokenId, _amount, "");
}
return rentalId;
}
| 11,624,589 | [
1,
2640,
326,
283,
496,
287,
443,
1724,
326,
3310,
471,
10929,
326,
2078,
443,
1724,
1056,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
389,
323,
1724,
12,
203,
3639,
1758,
389,
323,
1724,
280,
16,
203,
3639,
1758,
389,
5548,
16,
203,
3639,
2254,
5034,
389,
2316,
548,
16,
203,
3639,
2254,
1578,
389,
14419,
16,
203,
3639,
2254,
1105,
389,
8760,
16,
203,
3639,
2254,
1578,
389,
8949,
203,
565,
262,
2713,
1135,
261,
11890,
5034,
283,
496,
287,
548,
13,
288,
203,
3639,
1426,
353,
654,
39,
27,
5340,
273,
389,
588,
2532,
559,
24899,
5548,
1769,
203,
203,
3639,
309,
261,
291,
654,
39,
27,
5340,
597,
389,
8949,
480,
404,
13,
15226,
1962,
6275,
5621,
203,
3639,
309,
16051,
291,
654,
39,
27,
5340,
597,
389,
8949,
422,
374,
13,
15226,
1962,
6275,
5621,
203,
3639,
309,
261,
67,
8760,
422,
374,
13,
15226,
1962,
5326,
5621,
203,
3639,
309,
261,
67,
14419,
1545,
4552,
67,
8325,
862,
13,
15226,
1962,
9535,
5621,
203,
203,
3639,
283,
496,
287,
548,
273,
272,
18,
2972,
54,
319,
287,
548,
31,
203,
203,
3639,
272,
18,
547,
1031,
63,
547,
287,
548,
65,
273,
534,
319,
287,
12,
203,
5411,
389,
5548,
16,
203,
5411,
389,
2316,
548,
16,
203,
5411,
389,
323,
1724,
280,
16,
203,
5411,
1758,
12,
20,
3631,
203,
5411,
389,
14419,
16,
203,
5411,
389,
8760,
16,
203,
5411,
374,
16,
203,
5411,
389,
8949,
16,
203,
5411,
629,
203,
3639,
11272,
203,
3639,
272,
18,
8443,
54,
319,
287,
2673,
63,
67,
323,
1724,
280,
8009,
1289,
12,
547,
287,
548,
1769,
203,
3639,
965,
87,
18,
2
]
|
/*
Copyright (c) 2020 Fuel Labs
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.5.1;
/*
Authors: DappHub
License: GNU
Modified by: FuelLabs
*/
contract DSMath {
function ds_add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function ds_sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function ds_mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
}
contract ERC20 {
// METHODS
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
// EVENTS
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract FuelConstants {
// CONSTANTS
uint256 constant public BOND_SIZE = .1 ether; // required for block commitment
uint256 constant public FINALIZATION_DELAY = 7 days / 12; // ~ 1 weeks at 12 second block times
uint256 constant public SUBMISSION_DELAY = uint256(2 days) / 12; // ~ 2 day (should be 2 days) in Ethereum Blocks
uint256 constant public CLOSING_DELAY = uint256(90 days) / 12; // (should be 2 months)
uint256 constant public MAX_TRANSACTIONS_SIZE = 58823;
uint256 constant public TRANSACTION_ROOTS_MAX = 256;
// ASSEMBLY ONLY FRAUD CODES
uint256 constant FraudCode_InvalidMetadataBlockHeight = 0;
uint256 constant FraudCode_TransactionHashZero = 1;
uint256 constant FraudCode_TransactionIndexOverflow = 2;
uint256 constant FraudCode_MetadataOutputIndexOverflow = 3;
uint256 constant FraudCode_InvalidUTXOHashReference = 4;
uint256 constant FraudCode_InvalidReturnWitnessNotSpender = 5;
uint256 constant FraudCode_InputDoubleSpend = 6;
uint256 constant FraudCode_InvalidMerkleTreeRoot = 7;
uint256 constant FraudCode_MetadataBlockHeightUnderflow = 8;
uint256 constant FraudCode_MetadataBlockHeightOverflow = 9;
uint256 constant FraudCode_InvalidHTLCDigest = 10;
uint256 constant FraudCode_TransactionLengthUnderflow = 11;
uint256 constant FraudCode_TransactionLengthOverflow = 12;
uint256 constant FraudCode_InvalidTransactionInputType = 13;
uint256 constant FraudCode_TransactionOutputWitnessReferenceOverflow = 14;
uint256 constant FraudCode_InvalidTransactionOutputType = 15;
uint256 constant FraudCode_TransactionSumMismatch = 16;
uint256 constant FraudCode_TransactionInputWitnessReferenceOverflow = 17;
uint256 constant FraudCode_TransactionInputDepositZero = 18;
uint256 constant FraudCode_TransactionInputDepositWitnessOverflow = 19;
uint256 constant FraudCode_TransactionHTLCWitnessOverflow = 20;
uint256 constant FraudCode_TransactionOutputAmountLengthUnderflow = 21;
uint256 constant FraudCode_TransactionOutputAmountLengthOverflow = 22;
uint256 constant FraudCode_TransactionOutputTokenIDOverflow = 23;
uint256 constant FraudCode_TransactionOutputHTLCDigestZero = 24;
uint256 constant FraudCode_TransactionOutputHTLCExpiryZero = 25;
uint256 constant FraudCode_InvalidTransactionWitnessSignature = 26;
uint256 constant FraudCode_TransactionWitnessesLengthUnderflow = 27;
uint256 constant FraudCode_TransactionWitnessesLengthOverflow = 28;
uint256 constant FraudCode_TransactionInputsLengthUnderflow = 29;
uint256 constant FraudCode_TransactionInputsLengthOverflow = 30;
uint256 constant FraudCode_TransactionOutputsLengthUnderflow = 31;
uint256 constant FraudCode_TransactionOutputsLengthOverflow = 32;
uint256 constant FraudCode_TransactionMetadataLengthOverflow = 33;
uint256 constant FraudCode_TransactionInputSelectorOverflow = 34;
uint256 constant FraudCode_TransactionOutputSelectorOverflow = 35;
uint256 constant FraudCode_TransactionWitnessSelectorOverflow = 37;
uint256 constant FraudCode_TransactionUTXOType = 38;
uint256 constant FraudCode_TransactionUTXOOutputIndexOverflow = 39;
uint256 constant FraudCode_InvalidTransactionsNetLength = 40;
uint256 constant FraudCode_MetadataTransactionsRootsLengthOverflow = 41;
uint256 constant FraudCode_ComputedTransactionLengthOverflow = 42;
uint256 constant FraudCode_ProvidedDataOverflow = 43;
uint256 constant FraudCode_MetadataReferenceOverflow = 44;
uint256 constant FraudCode_OutputHTLCExpiryUnderflow = 45;
uint256 constant FraudCode_InvalidInputWithdrawalSpend = 46;
uint256 constant FraudCode_InvalidTypeReferenceMismatch = 47;
uint256 constant FraudCode_InvalidChangeInputSpender = 48;
uint256 constant FraudCode_InvalidTransactionRootIndexOverflow = 49;
// ASSEMBLY ONLY ERROR CODES
uint256 constant ErrorCode_InvalidTypeDeposit = 0;
uint256 constant ErrorCode_InputReferencedNotProvided = 1;
uint256 constant ErrorCode_InvalidReturnWitnessSelected = 2;
uint256 constant ErrroCode_InvalidReturnWitnessAddressEmpty = 3;
uint256 constant ErrroCode_InvalidSpenderWitnessAddressEmpty = 4;
uint256 constant ErrorCode_InvalidTransactionComparison = 5;
uint256 constant ErrorCode_WithdrawalAlreadyHappened = 6;
uint256 constant ErrorCode_BlockProducerNotCaller = 7;
uint256 constant ErrorCode_BlockBondAlreadyWithdrawn = 8;
uint256 constant ErrorCode_InvalidProofType = 9;
uint256 constant ErrorCode_BlockHashNotFound = 10;
uint256 constant ErrorCode_BlockHeightOverflow = 11;
uint256 constant ErrorCode_BlockHeightUnderflow = 12;
uint256 constant ErrorCode_BlockNotFinalized = 13;
uint256 constant ErrorCode_BlockFinalized = 14;
uint256 constant ErrorCode_TransactionRootLengthUnderflow = 15;
uint256 constant ErrorCode_TransactionRootIndexOverflow = 16;
uint256 constant ErrorCode_TransactionRootHashNotInBlockHeader = 17;
uint256 constant ErrorCode_TransactionRootHashInvalid = 18;
uint256 constant ErrorCode_TransactionLeafHashInvalid = 19;
uint256 constant ErrorCode_MerkleTreeHeightOverflow = 20;
uint256 constant ErrorCode_MerkleTreeRootInvalid = 21;
uint256 constant ErrorCode_InputIndexSelectedOverflow = 22;
uint256 constant ErrorCode_OutputIndexSelectedOverflow = 23;
uint256 constant ErrorCode_WitnessIndexSelectedOverflow = 24;
uint256 constant ErrorCode_TransactionUTXOIDInvalid = 25;
uint256 constant ErrorCode_FraudBlockHeightUnderflow = 26;
uint256 constant ErrorCode_FraudBlockFinalized = 27;
uint256 constant ErrorCode_SafeMathAdditionOverflow = 28;
uint256 constant ErrorCode_SafeMathSubtractionUnderflow = 29;
uint256 constant ErrorCode_SafeMathMultiplyOverflow = 30;
uint256 constant ErrorCode_TransferAmountUnderflow = 31;
uint256 constant ErrorCode_TransferOwnerInvalid = 32;
uint256 constant ErrorCode_TransferTokenIDOverflow = 33;
uint256 constant ErrorCode_TransferEtherCallResult = 34;
uint256 constant ErrorCode_TransferERC20Result = 35;
uint256 constant ErrorCode_TransferTokenAddress = 36;
uint256 constant ErrorCode_InvalidPreviousBlockHash = 37;
uint256 constant ErrorCode_TransactionRootsLengthUnderflow = 38;
uint256 constant ErrorCode_TransactionRootsLengthOverflow = 39;
uint256 constant ErrorCode_InvalidWithdrawalOutputType = 40;
uint256 constant ErrorCode_InvalidWithdrawalOwner = 41;
uint256 constant ErrorCode_InvalidDepositProof = 42;
uint256 constant ErrorCode_InvalidTokenAddress = 43;
uint256 constant ErrorCode_InvalidBlockHeightReference = 44;
uint256 constant ErrorCode_InvalidOutputIndexReference = 45;
uint256 constant ErrorCode_InvalidTransactionRootReference = 46;
uint256 constant ErrorCode_InvalidTransactionIndexReference = 47;
uint256 constant ErrorCode_ProofLengthOverflow = 48;
uint256 constant ErrorCode_InvalidTransactionsABILengthOverflow = 49;
// ASSEMBLY ONLY CONSTANTS
// Memory Layout * 32
// 0 -> 12 Swap for hashing, ecrecover, events data etc]
// 12 -> 44 Virtual Stack Memory (stack and swap behind writeable calldata for safety)
// 44 -> calldatasize() Calldata
// 44 + calldatasize() Free Memory
// Calldata Memory Position
uint256 constant Swap_MemoryPosition = 0 * 32; // Swap -> 12
uint256 constant Stack_MemoryPosition = 12 * 32; // Virtual Stack -> 44
uint256 constant Calldata_MemoryPosition = 44 * 32; // Calldata
// Length and Index max/min for Inputs, Outputs, Witnesses, Metadata
uint256 constant TransactionLengthMax = 8;
uint256 constant TransactionLengthMin = 0;
// Metadata, Witness and UTXO Proof Byte Size, Types and Lengths etc..
uint256 constant MetadataSize = 8;
uint256 constant WitnessSize = 65;
uint256 constant UTXOProofSize = 9 * 32;
uint256 constant DepositProofSize = 96;
uint256 constant TypeSize = 1;
uint256 constant LengthSize = 1;
uint256 constant TransactionLengthSize = 2;
uint256 constant DigestSize = 32;
uint256 constant ExpirySize = 4;
uint256 constant IndexSize = 1;
// Booleans
uint256 constant True = 1;
uint256 constant False = 0;
// Minimum and Maximum transaction byte length
uint256 constant TransactionSizeMinimum = 100;
uint256 constant TransactionSizeMaximum = 800;
// Maximum Merkle Tree Height
uint256 constant MerkleTreeHeightMaximum = 256;
// Select maximum number of transactions that can be included in a Side Chain block
uint256 constant MaxTransactionsInBlock = 2048;
// Ether Token Address (u256 chunk for assembly usage == address(0))
uint256 constant EtherToken = 0;
// Genesis Block Height
uint256 constant GenesisBlockHeight = 0;
// 4 i.e. (1) Input / (2) Output / (3) Witness Selection / (4) Metadata Selection
uint256 constant SelectionStackOffsetSize = 4;
// Topic Hashes
uint256 constant WithdrawalEventTopic = 0x782748bc04673eff1ae34a02239afa5a53a83abdfa31d65d7eea2684c4b31fe4;
uint256 constant FraudEventTopic = 0x62a5229d18b497dceab57b82a66fb912a8139b88c6b7979ad25772dc9d28ddbd;
// ASSEMBLY ONLY ENUMS
// Method Enums
uint256 constant Not_Finalized = 0;
uint256 constant Is_Finalized = 1;
uint256 constant Include_UTXOProofs = 1;
uint256 constant No_UTXOProofs = 0;
uint256 constant FirstProof = 0;
uint256 constant SecondProof = 1;
uint256 constant OneProof = 1;
uint256 constant TwoProofs = 2;
// Input Types Enums
uint256 constant InputType_UTXO = 0;
uint256 constant InputType_Deposit = 1;
uint256 constant InputType_HTLC = 2;
uint256 constant InputType_Change = 3;
// Input Sizes
uint256 constant InputSizes_UTXO = 33;
uint256 constant InputSizes_Change = 33;
uint256 constant InputSizes_Deposit = 33;
uint256 constant InputSizes_HTLC = 65;
// Output Types Enums
uint256 constant OutputType_UTXO = 0;
uint256 constant OutputType_withdrawal = 1;
uint256 constant OutputType_HTLC = 2;
uint256 constant OutputType_Change = 3;
// ASSEMBLY ONLY MEMORY STACK POSITIONS
uint256 constant Stack_InputsSum = 0;
uint256 constant Stack_OutputsSum = 1;
uint256 constant Stack_Metadata = 2;
uint256 constant Stack_BlockTip = 3;
uint256 constant Stack_UTXOProofs = 4;
uint256 constant Stack_TransactionHashID = 5;
uint256 constant Stack_BlockHeader = 6;
uint256 constant Stack_RootHeader = 19;
uint256 constant Stack_SelectionOffset = 7;
uint256 constant Stack_Index = 28;
uint256 constant Stack_SummingTokenID = 29;
uint256 constant Stack_SummingToken = 30;
// Selection Stack Positions (Comparison Proof Selections)
uint256 constant Stack_MetadataSelected = 8;
uint256 constant Stack_SelectedInputLength = 9;
uint256 constant Stack_OutputSelected = 10;
uint256 constant Stack_WitnessSelected = 11;
uint256 constant Stack_MetadataSelected2 = 12;
uint256 constant Stack_SelectedInputLength2 = 13;
uint256 constant Stack_OutputSelected2 = 14;
uint256 constant Stack_WitnessSelected2 = 15;
uint256 constant Stack_RootProducer = 16;
uint256 constant Stack_Witnesses = 17;
uint256 constant Stack_MerkleProofLeftish = 23;
uint256 constant Stack_ProofNumber = 25;
uint256 constant Stack_FreshMemory = 26;
uint256 constant Stack_MetadataLength = 31;
// Storage Positions (based on Solidity compilation)
uint256 constant Storage_deposits = 0;
uint256 constant Storage_withdrawals = 1;
uint256 constant Storage_blockTransactionRoots = 2;
uint256 constant Storage_blockCommitments = 3;
uint256 constant Storage_tokens = 4;
uint256 constant Storage_numTokens = 5;
uint256 constant Storage_blockTip = 6;
uint256 constant Storage_blockProducer = 7;
}
contract Fuel is FuelConstants, DSMath {
// EVENTS
event DepositMade(address indexed account, address indexed token, uint256 amount);
event WithdrawalMade(address indexed account, address token, uint256 amount, uint256 indexed blockHeight, uint256 transactionRootIndex, bytes32 indexed transactionLeafHash, uint8 outputIndex, bytes32 transactionHashId);
event TransactionsSubmitted(bytes32 indexed transactionRoot, address producer, bytes32 indexed merkleTreeRoot, bytes32 indexed commitmentHash);
event BlockCommitted(address blockProducer, bytes32 indexed previousBlockHash, uint256 indexed blockHeight, bytes32[] transactionRoots);
event FraudCommitted(uint256 indexed previousTip, uint256 indexed currentTip, uint256 indexed fraudCode);
event TokenIndex(address indexed token, uint256 indexed index);
// STATE STORAGE
// depositHashID => amount [later clearable in deposit] sload(keccak256(0, 64) + 5)
mapping(bytes32 => uint256) public deposits; // STORAGE 0
// block height => withdrawal id => bool(has been withdrawn) [later clearable in withdraw]
// lets treat block withdrawals as tx hash bytes(0) output (0)
mapping(uint256 => mapping(bytes32 => bool)) public withdrawals; // STORAGE 1
// transactions hash => Ethereum block number included [later clearable in withdraw]
mapping(bytes32 => uint256) public blockTransactionRoots; // STORAGE 2
// blockNumber => blockHash all block commitment hash headers Mapping actually better than array IMO, use tip as len
mapping(uint256 => bytes32) public blockCommitments; // STORAGE 3
// tokens address => token ID number
mapping(address => uint256) public tokens; // STORAGE 4
// number of tokens (1 for Ether ID 0)
uint256 public numTokens = 1; // STORAGE 5
// the current side-chain block height/tip [changed in commitBlock / submitFraudProof]
uint256 public blockTip; // STORAGE 6
// block producer (set to zero for permissionless, must be account) [changed in constructor / submitFraudProof]
address public blockProducer; // STORAGE 7
// CONSTRUCTOR
constructor(address producer) public {
// compute genesis block hash
address genesisProducer = address(0);
// TODO low-priority set a clever previous block hash
bytes32 previousBlockHash = bytes32(0);
uint256 blockHeight = uint256(0);
bytes32[] memory transactionRoots;
bytes32 genesisBlockHash = keccak256(abi.encode(genesisProducer, previousBlockHash, blockHeight, GenesisBlockHeight, transactionRoots));
// STORAGE commit the genesis block hash header to storage as Zero block..
blockCommitments[GenesisBlockHeight] = genesisBlockHash;
// STORAGE setup block producer
blockProducer = producer;
// Setup Ether token index
emit TokenIndex(address(0), 1);
// LOG emit all pertinent details of the Genesis block
emit BlockCommitted(genesisProducer, previousBlockHash, blockHeight, transactionRoots);
}
// STATE Changing Methods
function deposit(address account, address token, uint256 amount) external payable {
// Compute deposit hash Identifier
bytes32 depositHashId = keccak256(abi.encode(account, token, block.number));
// Assert amount is greater than Zero
assert(amount > 0);
// Handle transfer details
if (token != address(0)) {
assert(ERC20(token).allowance(msg.sender, address(this)) >= amount); // check allowance
assert(ERC20(token).transferFrom(msg.sender, address(this), amount)); // transferFrom
} else {
assert(msg.value == amount); // commit ether transfer
}
// register token with an index if it isn't already
if (token != address(0) && tokens[token] == 0) {
// STORAGE register token with index
tokens[token] = numTokens;
// STORAGE MOD increase token index
numTokens = ds_add(numTokens, 1);
// LOG emit token registry index
emit TokenIndex(token, numTokens);
}
// STORAGE notate deposit in storage
deposits[depositHashId] = ds_add(deposits[depositHashId], amount);
// Log essential deposit details
emit DepositMade(account, token, amount);
}
function submitTransactions(bytes32 merkleTreeRoot, bytes calldata transactions) external {
// require the sender is not a contract
assembly {
// Require if caller/msg.sender is a contract
if gt(extcodesize(caller()), 0) { revert(0, 0) }
// Calldata Max size enforcement (4m / 68)
if gt(calldatasize(), MAX_TRANSACTIONS_SIZE) { revert(0, 0) }
}
// Commitment hash
bytes32 commitmentHash = keccak256(transactions);
// Construct Transaction Root Hash
bytes32 transactionRoot = keccak256(abi.encode(msg.sender, merkleTreeRoot, commitmentHash));
// Assert this transactions blob cannot already exist
assert(blockTransactionRoots[transactionRoot] == 0);
// STORAGE notate transaction root in storage at a specified Ethereum block
blockTransactionRoots[transactionRoot] = block.number;
// LOG Transaction submitted, the original data
emit TransactionsSubmitted(transactionRoot, msg.sender, merkleTreeRoot, commitmentHash);
}
function commitBlock(uint256 blockHeight, bytes32[] calldata transactionRoots) external payable {
bytes32 previousBlockHash = blockCommitments[blockTip];
bytes32 blockHash = keccak256(abi.encode(msg.sender, previousBlockHash, blockHeight, block.number, transactionRoots));
// Assert require value be bond size
assert(msg.value == BOND_SIZE);
// Assert at least one root submission
assert(transactionRoots.length > 0);
// Assert at least one root submission
assert(transactionRoots.length < TRANSACTION_ROOTS_MAX);
// Assert the transaction roots exists
for (uint256 transactionRootIndex = 0;
transactionRootIndex < transactionRoots.length;
transactionRootIndex = ds_add(transactionRootIndex, 1)) {
// Transaction Root must Exist in State
assert(blockTransactionRoots[transactionRoots[transactionRootIndex]] > 0);
// add root expiry here..
// Assert transaction root is younger than 3 days, and block producer set, than only block producer can make the block
if (block.number < ds_add(blockTransactionRoots[transactionRoots[transactionRootIndex]], SUBMISSION_DELAY) && blockProducer != address(0)) {
assert(msg.sender == blockProducer);
}
}
// Require block height must be 1 ahead of tip REVERT nicely (be forgiving)
require(blockHeight == ds_add(blockTip, 1));
// STORAGE write block hash commitment to storage
blockCommitments[blockHeight] = blockHash;
// STORAGE set new block tip
blockTip = blockHeight;
// LOG emit all pertinant details in Log Data
emit BlockCommitted(msg.sender, previousBlockHash, blockHeight, transactionRoots);
}
// Submit Fraud or withdrawal proofs (i.e. Implied Consensus Rule Enforcement)
function submitProof(bytes calldata) external payable {
assembly {
// Assign all calldata into free memory, remove 4 byte signature and 64 bytes size/length data (68 bytes)
// Note, We only write data to memory once, than reuse it for almost every function for better computational efficiency
calldatacopy(Calldata_MemoryPosition, 68, calldatasize())
// Assign fresh memory pointer to Virtual Stack
mpush(Stack_FreshMemory, add3(Calldata_MemoryPosition, calldatasize(), mul32(2)))
// Handle Proof Type
switch selectProofType()
case 0 { // ProofType_MalformedBlock
verifyBlockProof()
}
case 1 { // ProofType_MalformedTransaction
// Check proof lengths for overflow
verifyTransactionProofLengths(OneProof)
// Verify Malformed Transaction Proof
verifyTransactionProof(FirstProof, No_UTXOProofs, Not_Finalized)
}
case 2 { // ProofType_InvalidTransaction
// Check proof lengths for overflow
verifyTransactionProofLengths(OneProof)
// Check for Invalid Transaction Sum Amount Totals
// Check for HTLC Data Construction / Witness Signature Specification
verifyTransactionProof(FirstProof, Include_UTXOProofs, Not_Finalized)
}
case 3 { // ProofType_InvalidTransactionInput
// Check proof lengths for overflow
verifyTransactionProofLengths(TwoProofs)
// Check for Invalid UTXO Reference (i.e. Reference a UTXO that does not exist or is Invalid!)
verifyTransactionProof(FirstProof, No_UTXOProofs, Not_Finalized) // Fraud Tx
verifyTransactionProof(SecondProof, No_UTXOProofs, Not_Finalized) // Valid Tx
// Select Input Type
let firstInputType := selectInputType(selectInputSelected(FirstProof))
// Assert fraud input is not a Deposit Type (deposits are checked in verifyTransactionProof)
assertOrInvalidProof(iszero(eq(firstInputType, InputType_Deposit)),
ErrorCode_InvalidTypeDeposit)
// Fraud Tx 0 Proof: Block Height, Root Index, Tx Index Selected by Metadata
let firstMetadataBlockHeight, firstMetadataTransactionRootIndex,
firstMetadataTransactionIndex, firstMetadataOutputIndex := selectMetadata(
selectMetadataSelected(FirstProof))
// Ensure block heights are the same Metadata Block Height = Second Proof Block Height
assertOrInvalidProof(eq(firstMetadataBlockHeight,
selectBlockHeight(selectBlockHeader(SecondProof))),
ErrorCode_InvalidBlockHeightReference)
// Check transaction root index overflow Metadata Roots Index < Second Proof Block Roots Length
assertOrFraud(lt(firstMetadataTransactionRootIndex,
selectTransactionRootsLength(selectBlockHeader(SecondProof))),
FraudCode_InvalidTransactionRootIndexOverflow)
// Check transaction roots
assertOrInvalidProof(eq(firstMetadataTransactionRootIndex,
selectTransactionRootIndex(selectTransactionRoot(SecondProof))),
ErrorCode_InvalidTransactionRootReference)
// Check transaction index overflow
// Second Proof is Leftish (false if Rightmost Leaf in Merkle Tree!)
let secondProofIsLeftish := mstack(Stack_MerkleProofLeftish)
// Enforce transactionIndexOverflow
assertOrFraud(or(
secondProofIsLeftish,
lte(firstMetadataTransactionIndex, selectTransactionIndex(selectTransactionData(SecondProof))) // Or is most right!
), FraudCode_TransactionIndexOverflow)
// Check transaction index
assertOrInvalidProof(eq(firstMetadataTransactionIndex,
selectTransactionIndex(selectTransactionData(SecondProof))),
ErrorCode_InvalidTransactionIndexReference)
// Check that second transaction isn't empty
assertOrFraud(gt(constructTransactionLeafHash(selectTransactionData(SecondProof)), 0),
FraudCode_TransactionHashZero)
// Select Lengths and Use Them as Indexes (let Index = Length; lt; Index--)
let transactionLeafData, inputsLength,
secondOutputsLength, witnessesLength := selectAndVerifyTransactionDetails(selectTransactionData(SecondProof))
// Check output selection overflow
assertOrFraud(lt(firstMetadataOutputIndex, secondOutputsLength),
FraudCode_MetadataOutputIndexOverflow)
// Second output index
let secondOutputIndex := selectOutputIndex(selectTransactionData(SecondProof))
// Check outputs are the same
assertOrInvalidProof(eq(firstMetadataOutputIndex, secondOutputIndex),
ErrorCode_InvalidOutputIndexReference)
// Select second output
let secondOutput := selectOutputSelected(SecondProof)
let secondOutputType := selectOutputType(secondOutput)
// Check output is not spending withdrawal
assertOrFraud(iszero(eq(secondOutputType, OutputType_withdrawal)),
FraudCode_InvalidInputWithdrawalSpend)
// Invalid Type Spend
assertOrFraud(eq(firstInputType, secondOutputType),
FraudCode_InvalidTypeReferenceMismatch)
// Construct second transaction hash id
let secondTransactionHashID := constructTransactionHashID(selectTransactionData(SecondProof))
// Construct Second UTXO ID Proof
let secondUTXOProof := constructUTXOProof(secondTransactionHashID,
selectOutputIndex(selectTransactionData(SecondProof)),
selectOutputSelected(SecondProof))
let secondUTXOID := constructUTXOID(secondUTXOProof)
// Select first UTXO ID
let firstUTXOID := selectUTXOID(selectInputSelected(FirstProof))
// Check UTXOs are the same
assertOrFraud(eq(firstUTXOID, secondUTXOID),
FraudCode_InvalidUTXOHashReference)
// Handle Change Input Enforcement
if eq(selectOutputType(secondOutput), OutputType_Change) {
// Output HTLC
let length, amount, ownerAsWitnessIndex,
tokenID := selectAndVerifyOutput(secondOutput, True)
// Return Witness Recovery
// Return Witness Signature
let outputWitnessSignature := selectWitnessSignature(selectTransactionWitnesses(selectTransactionData(SecondProof)),
ownerAsWitnessIndex)
// Construct Second Transaction Hash ID
let outputTransactionHashID := constructTransactionHashID(selectTransactionData(SecondProof))
// Get Witness Signature
let outputWitnessAddress := ecrecoverPacked(outputTransactionHashID,
outputWitnessSignature)
// Spender Witness Recovery
// Select First Proof Witness Index from Input
let unused1, unused2, spenderWitnessIndex := selectAndVerifyInputUTXO(selectInputSelected(FirstProof),
TransactionLengthMax)
// Spender Witness Signature
let spenderWitnessSignature := selectWitnessSignature(selectTransactionWitnesses(selectTransactionData(FirstProof)),
spenderWitnessIndex)
// Construct First Tx ID
let spenderTransactionHashID := constructTransactionHashID(selectTransactionData(FirstProof))
// Spender Witness Address
let spenderWitnessAddress := ecrecoverPacked(spenderTransactionHashID,
spenderWitnessSignature)
// Assert Spender must be Output Witness
assertOrFraud(eq(spenderWitnessAddress, outputWitnessAddress),
FraudCode_InvalidChangeInputSpender)
}
// Handle HTLC Input Enforcement
if eq(selectOutputType(secondOutput), OutputType_HTLC) {
// Output HTLC
let length, amount, owner, tokenID,
digest, expiry, returnWitnessIndex := selectAndVerifyOutputHTLC(secondOutput,
TransactionLengthMax)
// Handle Is HTLC Expired, must be returnWitness
if gte(selectBlockHeight(selectBlockHeader(FirstProof)), expiry) {
// Return Witness Recovery
// Return Witness Signature
let returnWitnessSignature := selectWitnessSignature(selectTransactionWitnesses(selectTransactionData(SecondProof)),
returnWitnessIndex)
// Construct Second Transaction Hash ID
let returnTransactionHashID := constructTransactionHashID(selectTransactionData(SecondProof))
// Get Witness Signature
let returnWitnessAddress := ecrecoverPacked(returnTransactionHashID,
returnWitnessSignature)
// Spender Witness Recovery
// Select First Proof Witness Index from Input
let unused1, unused2, inputWitnessIndex, preImage := selectAndVerifyInputHTLC(selectInputSelected(FirstProof),
TransactionLengthMax)
// Spender Witness Signature
let spenderWitnessSignature := selectWitnessSignature(selectTransactionWitnesses(selectTransactionData(FirstProof)),
inputWitnessIndex)
// Construct First Tx ID
let spenderTransactionHashID := constructTransactionHashID(selectTransactionData(FirstProof))
// Spender Witness Address
let spenderWitnessAddress := ecrecoverPacked(spenderTransactionHashID,
spenderWitnessSignature)
// Assert Spender must be Return Witness!
assertOrFraud(eq(spenderWitnessAddress, returnWitnessAddress),
FraudCode_InvalidReturnWitnessNotSpender)
}
}
}
case 4 { // ProofType_InvalidTransactionDoubleSpend
// Check proof lengths for overflow
verifyTransactionProofLengths(TwoProofs)
// Check for Invalid Transaction Double Spend (Same Input Twice)
verifyTransactionProof(FirstProof, No_UTXOProofs, Not_Finalized) // Accused Fraud Tx
verifyTransactionProof(SecondProof, No_UTXOProofs, Not_Finalized) // Valid Tx
// Get transaction data zero and 1
let transaction0 := selectTransactionData(FirstProof)
let transaction1 := selectTransactionData(SecondProof)
// Block Height Difference
let blockHeightDifference := iszero(eq(selectBlockHeight(selectBlockHeader(FirstProof)),
selectBlockHeight(selectBlockHeader(SecondProof))))
// Transaction Root Difference
let transactionRootIndexDifference := iszero(eq(selectTransactionRootIndex(selectTransactionRoot(FirstProof)),
selectTransactionRootIndex(selectTransactionRoot(SecondProof))))
// Transaction Index Difference
let transactionIndexDifference := iszero(eq(selectTransactionIndex(transaction0),
selectTransactionIndex(transaction1)))
// Transaction Input Index Difference
let transactionInputIndexDifference := iszero(eq(selectInputIndex(transaction0),
selectInputIndex(transaction1)))
// Check that the transactions are different
assertOrInvalidProof(or(
or(blockHeightDifference, transactionRootIndexDifference),
or(transactionIndexDifference, transactionInputIndexDifference) // Input Index is Different
), ErrorCode_InvalidTransactionComparison)
// Assert Inputs are Different OR FRAUD Double Spend!
assertOrFraud(iszero(eq(selectInputSelectedHash(FirstProof),
selectInputSelectedHash(SecondProof))),
FraudCode_InputDoubleSpend)
}
case 5 { // ProofType_UserWithdrawal
// Check proof lengths for overflow
verifyTransactionProofLengths(OneProof)
// Verify transaction proof
verifyTransactionProof(FirstProof, No_UTXOProofs, Is_Finalized)
// Run the withdrawal Sequence
let output := selectOutputSelected(FirstProof)
let length, outputAmount, outputOwner, outputTokenID := selectAndVerifyOutput(output, False)
// Check Proof Type is Correct
assertOrInvalidProof(eq(selectOutputType(output), 1), ErrorCode_InvalidWithdrawalOutputType)
// Check Proof Type is Correct
assertOrInvalidProof(eq(outputOwner, caller()), ErrorCode_InvalidWithdrawalOwner)
// Get transaction details
let transactionRootIndex := selectTransactionRootIndex(selectTransactionRoot(FirstProof))
let transactionLeafHash := constructTransactionLeafHash(selectTransactionData(FirstProof))
let outputIndex := selectOutputIndex(selectTransactionData(FirstProof))
let blockHeight := selectBlockHeight(selectBlockHeader(FirstProof))
// Construct withdrawal hash id
let withdrawalHashID := constructWithdrawalHashID(transactionRootIndex,
transactionLeafHash, outputIndex)
// This output has not been withdrawn yet!
assertOrInvalidProof(eq(getWithdrawals(blockHeight, withdrawalHashID), False),
ErrorCode_WithdrawalAlreadyHappened)
// withdrawal Token
let withdrawalToken := selectWithdrawalToken(FirstProof)
// Transfer amount out
transfer(outputAmount, outputTokenID, withdrawalToken, outputOwner)
// Set withdrawals
setWithdrawals(blockHeight, withdrawalHashID, True)
// Construct Log Data for withdrawal
mstore(mul32(1), withdrawalToken)
mstore(mul32(2), outputAmount)
mstore(mul32(3), transactionRootIndex)
mstore(mul32(4), outputIndex)
mstore(mul32(5), constructTransactionHashID(selectTransactionData(FirstProof)))
// add transactionHash
// Log withdrawal data and topics
log4(mul32(1), mul32(5), WithdrawalEventTopic, outputOwner,
blockHeight, transactionLeafHash)
}
case 6 { // ProofType_BondWithdrawal
// Select proof block header
let blockHeader := selectBlockHeader(FirstProof)
// Setup block producer withdrawal hash ID (i.e. Zero)
let withdrawalHashID := 0
// Transaction Leaf Hash (bond withdrawal hash is zero)
let transactionLeafHash := 0
// Block Producer
let blockProducer := caller()
// block height
let blockHeight := selectBlockHeight(blockHeader)
// Verify block header proof is finalized!
verifyBlockHeader(blockHeader, Is_Finalized)
// Assert Caller is Block Producer
assertOrInvalidProof(eq(selectBlockProducer(blockHeader), blockProducer),
ErrorCode_BlockProducerNotCaller)
// Assert Block Bond withdrawal has not been Made!
assertOrInvalidProof(eq(getWithdrawals(blockHeight, withdrawalHashID), False),
ErrorCode_BlockBondAlreadyWithdrawn)
// Transfer Bond Amount back to Block Producer
transfer(BOND_SIZE, EtherToken, EtherToken, blockProducer)
// Set withdrawal
setWithdrawals(blockHeight, withdrawalHashID, True)
// Construct Log Data for withdrawal
mstore(mul32(1), EtherToken)
mstore(mul32(2), BOND_SIZE)
mstore(mul32(3), 0)
mstore(mul32(4), 0)
// Log withdrawal data and topics
log4(mul32(1), mul32(4), WithdrawalEventTopic, blockProducer,
blockHeight,
transactionLeafHash)
}
// Invalid Proof Type
default { assertOrInvalidProof(0, ErrorCode_InvalidProofType) }
// Ensure Execution Stop
stop()
//
// VERIFICATION METHODS
// For verifying proof data and determine fraud or validate withdrawals
//
// Verify Invalid Block Proof
function verifyBlockProof() {
/*
Block Construction Proof:
- Type
- Lengths
- BlockHeader
- TransactionRootHeader
- TransactionRootData
*/
// Start Proof Position past Proof Type
let proofMemoryPosition := safeAdd(Calldata_MemoryPosition, mul32(1))
// Select Proof Lengths
let blockHeaderLength := load32(proofMemoryPosition, 0)
let transactionRootLength := load32(proofMemoryPosition, 1)
let transactionsLength := load32(proofMemoryPosition, 2)
// Verify the Lengths add up to calldata size
verifyProofLength(add4(mul32(3), blockHeaderLength,
transactionRootLength, transactionsLength))
// Select Proof Memory Positions
let blockHeader := selectBlockHeader(FirstProof)
let transactionRoot := selectTransactionRoot(FirstProof)
// Transactions are After Transaction Root, Plus 64 Bytes (for bytes type metadata from ABI Encoding)
let transactions := safeAdd(transactionRoot, transactionRootLength)
// Verify Block Header
verifyBlockHeader(blockHeader, Not_Finalized)
// Verify Transaction Root Header
verifyTransactionRootHeader(blockHeader, transactionRoot)
// Get solidity abi encoded length for transactions blob
let transactionABILength := selectTransactionABILength(transactions)
// Check for overflow
assertOrInvalidProof(lt(transactionABILength, transactionsLength),
ErrorCode_InvalidTransactionsABILengthOverflow)
// Verify Transaction Hash Commitment
verifyTransactionRootData(transactionRoot,
selectTransactionABIData(transactions),
transactionABILength)
}
// Verify proof length for overflows
function verifyProofLength(proofLengthWithoutType) {
let calldataMetadataSize := 68
let typeSize := mul32(1)
let computedCalldataSize := add3(calldataMetadataSize, typeSize, proofLengthWithoutType)
// Check for overflow
assertOrInvalidProof(eq(computedCalldataSize, calldatasize()),
ErrorCode_ProofLengthOverflow)
}
// Verify Block Header
function verifyBlockHeader(blockHeader, assertFinalized) {
/*
- Block Header:
- blockProducer [32 bytes] -- padded address
- previousBlockHash [32 bytes]
- blockHeight [32 bytes]
- ethereumBlockNumber [32 bytes]
- transactionRoots [64 + dynamic bytes]
*/
// Construct blockHash from Block Header
let blockHash := constructBlockHash(blockHeader)
// Select BlockHeight from Memory
let blockHeight := selectBlockHeight(blockHeader)
// Previous block hash
let previousBlockHash := selectPreviousBlockHash(blockHeader)
// Transaction Roots Length
let transactionRootsLength := selectTransactionRootsLength(blockHeader)
// Assert Block is not Genesis
assertOrInvalidProof(gt(blockHeight, GenesisBlockHeight), ErrorCode_BlockHeightUnderflow)
// Assert Block Height is Valid (i.e. before tip)
assertOrInvalidProof(lte(blockHeight, getBlockTip()), ErrorCode_BlockHeightOverflow)
// Assert Previous Block Hash
assertOrInvalidProof(eq(getBlockCommitments(safeSub(blockHeight, 1)), previousBlockHash), ErrorCode_InvalidPreviousBlockHash)
// Transactions roots length underflow
assertOrInvalidProof(gt(transactionRootsLength, 0), ErrorCode_TransactionRootsLengthUnderflow)
// Assert Block Commitment Exists
assertOrInvalidProof(eq(getBlockCommitments(blockHeight), blockHash), ErrorCode_BlockHashNotFound)
// If requested, Assert Block is Finalized
if eq(assertFinalized, 1) {
assertOrInvalidProof(gte(
number(),
safeAdd(selectEthereumBlockNumber(blockHeader), FINALIZATION_DELAY) // ethBlock + delay
), ErrorCode_BlockNotFinalized)
}
// If requested, Assert Block is Not Finalized
if iszero(assertFinalized) { // underflow protected!
assertOrInvalidProof(lt(
number(), // ethereumBlockNumber
safeAdd(selectEthereumBlockNumber(blockHeader), FINALIZATION_DELAY) // finalization delay
), ErrorCode_BlockFinalized)
}
}
// Verify Transaction Root Header (Assume Block Header is Valid)
function verifyTransactionRootHeader(blockHeader, transactionRoot) {
/*
- Block Header:
- blockProducer [32 bytes] -- padded address
- previousBlockHash [32 bytes]
- blockHeight [32 bytes]
- ethereumBlockNumber [32 bytes]
- transactionRoots [64 + dynamic bytes]
- Transaction Root Header:
- transactionRootProducer [32 bytes] -- padded address
- transactionRootMerkleTreeRoot [32 bytes]
- transactionRootCommitmentHash [32 bytes]
- transactionRootIndex [32 bytes]
*/
// Get number of transaction roots
let transactionRootsLength := selectTransactionRootsLength(blockHeader)
// Get transaction root index
let transactionRootIndex := selectTransactionRootIndex(transactionRoot)
// Assert root index is not overflowing
assertOrInvalidProof(lt(transactionRootIndex, transactionRootsLength), ErrorCode_TransactionRootIndexOverflow)
// Assert root invalid overflow
assertOrInvalidProof(lt(transactionRootsLength, TRANSACTION_ROOTS_MAX), ErrorCode_TransactionRootsLengthOverflow)
// Construct transaction root
let transactionRootHash := keccak256(transactionRoot, mul32(3))
// Assert transaction root index is correct!
assertOrInvalidProof(eq(
transactionRootHash,
load32(blockHeader, safeAdd(6, transactionRootIndex)) // blockHeader transaction root
), ErrorCode_TransactionRootHashNotInBlockHeader)
}
// Construct commitment hash
function constructCommitmentHash(transactions, transactionsLength) -> commitmentHash {
commitmentHash := keccak256(transactions, transactionsLength)
}
function selectTransactionABIData(transactionsABIEncoded) -> transactions {
transactions := safeAdd(transactionsABIEncoded, mul32(2))
}
function selectTransactionABILength(transactionsABIEncoded) -> transactionsLength {
transactionsLength := load32(transactionsABIEncoded, 1)
}
// Verify Transaction Root Data is Valid (Assuming Transaction Root Valid)
function verifyTransactionRootData(transactionRoot, transactions, transactionsLength) {
// Select Transaction Data Root
let commitmentHash := selectCommitmentHash(transactionRoot)
// Check provided transactions data! THIS HASH POSITION MIGHT BE WRONG due to Keccak Encoding
let constructedCommitmentHash := constructCommitmentHash(transactions, transactionsLength)
// Assert or Invalid Data Provided
assertOrInvalidProof(eq(
commitmentHash,
constructedCommitmentHash
), ErrorCode_TransactionRootHashInvalid)
// Select Merkle Tree Root Provided
let merkleTreeRoot := selectMerkleTreeRoot(transactionRoot)
// Assert committed root must be the same as computed root! // THIS HASH MIGHT BE WRONG (hash POS check)
assertOrFraud(eq(
merkleTreeRoot,
constructMerkleTreeRoot(transactions, transactionsLength)
), FraudCode_InvalidMerkleTreeRoot)
}
// Verify Transaction Proof
function verifyTransactionProof(proofIndex, includeUTXOProofs, assertFinalized) {
/*
Transaction Proof:
- Lengths
- BlockHeader
- TransactionRootHeader
- TransactionMerkleProof
- TransactionData
- TransactionUTXOProofs
*/
// we are on proof 1
if gt(proofIndex, 0) {
// Notate across global stack we are on proof 1 validation
mpush(Stack_ProofNumber, proofIndex)
}
// Select Memory Positions
let blockHeader := selectBlockHeader(proofIndex)
let transactionRoot := selectTransactionRoot(proofIndex)
let transactionMerkleProof := selectTransactionMerkleProof(proofIndex)
let transactionData := selectTransactionData(proofIndex)
// Verify Block Header
verifyBlockHeader(blockHeader, assertFinalized)
// Verify Transaction Root Header
verifyTransactionRootHeader(blockHeader, transactionRoot)
// Verify Transaction Leaf
verifyTransactionLeaf(transactionRoot, transactionData, transactionMerkleProof)
// Construct Transaction Leaf Hash (Again :(
let transactionLeafHash := constructTransactionLeafHash(transactionData)
// If transaction hash is not zero hash, than go and verify it!
if gt(transactionLeafHash, 0) {
// Transaction UTXO Proofs
let transactionUTXOProofs := 0
// Include UTXO Proofs
if gt(includeUTXOProofs, 0) {
transactionUTXOProofs := selectTransactionUTXOProofs(proofIndex)
}
// Verify Transaction Data
verifyTransactionData(transactionData, transactionUTXOProofs)
}
// Ensure We are now validating proof 0 again
mpop(Stack_ProofNumber)
}
// Verify Transaction Leaf (Assume Transaction Root Header is Valid)
function verifyTransactionLeaf(transactionRoot, transactionData, merkleProof) {
/*
- Transaction Root Header:
- transactionRootProducer [32 bytes] -- padded address
- transactionRootMerkleTreeRoot [32 bytes]
- transactionRootCommitmentHash [32 bytes]
- transactionRootIndex [32 bytes]
- Transaction Data:
- input index [32 bytes] -- padded uint8
- output index [32 bytes] -- padded uint8
- witness index [32 bytes] -- padded uint8
- transactionInputsLength [32 bytes] -- padded uint8
- transactionIndex [32 bytes] -- padded uint32
- transactionLeafData [dynamic bytes]
- Transaction Merkle Proof:
- oppositeTransactionLeaf [32 bytes]
- merkleProof [64 + dynamic bytes]
*/
// Select Merkle Tree Root
let merkleTreeRoot := selectMerkleTreeRoot(transactionRoot)
// Select Merkle Proof Height
let treeHeight := selectMerkleTreeHeight(merkleProof)
// Select Tree (ahead of Array length)
let treeMemoryPosition := selectMerkleTree(merkleProof)
// Select Transaction Index
let transactionIndex := selectTransactionIndex(transactionData)
// Assert Valid Merkle Tree Height (i.e. below Maximum)
assertOrInvalidProof(lt(treeHeight, MerkleTreeHeightMaximum),
ErrorCode_MerkleTreeHeightOverflow)
// Select computed hash, initialize with opposite leaf hash
let computedHash := selectOppositeTransactionLeaf(merkleProof)
// Assert Leaf Hash is base of Merkle Proof
assertOrInvalidProof(eq(
constructTransactionLeafHash(transactionData), // constructed
computedHash // proof provided
), ErrorCode_TransactionLeafHashInvalid)
// Clean Rightmost (leftishness) Detection Var (i.e. any previous use of this Stack Position)
mpop(Stack_MerkleProofLeftish)
// Iterate Through Merkle Proof Depths
// https://crypto.stackexchange.com/questions/31871/what-is-the-canonical-way-of-creating-merkle-tree-branches
for { let depth := 0 } lt(depth, treeHeight) { depth := safeAdd(depth, 1) } {
// get the leaf hash
let proofLeafHash := load32(treeMemoryPosition, depth)
// Determine Proof Direction the merkle brand left: tx index % 2 == 0
switch eq(smod(transactionIndex, 2), 0)
// Direction is left branch
case 1 {
mstore(mul32(1), computedHash)
mstore(mul32(2), proofLeafHash)
// Leftishness Detected in Proof, This is not Rightmost
mpush(Stack_MerkleProofLeftish, True)
}
// Direction is right branch
case 0 {
mstore(mul32(1), proofLeafHash)
mstore(mul32(2), computedHash)
}
default { revert(0, 0) } // Direction is Invalid, Ensure no other cases!
// Construct Depth Hash
computedHash := keccak256(mul32(1), mul32(2))
// Shift transaction index right by 1
transactionIndex := shr(1, transactionIndex)
}
// Assert constructed merkle tree root is provided merkle tree root, or else, Invalid Inclusion!
assertOrInvalidProof(eq(computedHash, merkleTreeRoot), ErrorCode_MerkleTreeRootInvalid)
}
// Verify Transaction Input Metadata
function verifyTransactionInputMetadata(blockHeader, rootHeader, metadata, blockTip, inputIndex) {
// Block Height
let metadataBlockHeight, metadataTransactionRootIndex,
metadataTransactionIndex, metadataOutputIndex := selectMetadata(metadata)
// Select Transaction Block Height
let blockHeight := selectBlockHeight(blockHeader)
let transactionRootIndex := selectTransactionRootIndex(rootHeader)
// Assert input index overflow (i.e. metadata does not exist)
assertOrFraud(lt(inputIndex, mstack(Stack_MetadataLength)),
FraudCode_MetadataReferenceOverflow)
// Assert Valid Metadata Block height
assertOrFraud(gt(metadataBlockHeight, 0), FraudCode_MetadataBlockHeightUnderflow)
// Assert Valid Metadata Block height
assertOrFraud(lt(metadataTransactionRootIndex, TRANSACTION_ROOTS_MAX),
FraudCode_InvalidTransactionRootIndexOverflow)
// Cannot spend past it's own root index (i.e. tx 1 cant spend tx 2 at root index + 1)
// Can't be past block tip or past it's own block (can't reference the future)
assertOrFraud(lte(metadataBlockHeight, blockTip),
FraudCode_MetadataBlockHeightOverflow)
// Check overflow of current block height
assertOrFraud(lte(metadataBlockHeight, blockHeight),
FraudCode_MetadataBlockHeightOverflow)
// Can't reference in the future!!
// If Meta is Ref. Block Height of Itself, and Ref. Root Index > Itself, that's Fraud!
assertOrFraud(or(iszero(eq(metadataBlockHeight, blockHeight)), // block height is different
lte(metadataTransactionRootIndex, transactionRootIndex)), // metadata root index <= self root index
FraudCode_InvalidTransactionRootIndexOverflow)
// Need to cover referencing a transaction index in the same block, but past this tx
// txs must always reference txs behind it, or else it's fraud
// Check Output Index
assertOrFraud(lt(metadataOutputIndex, TransactionLengthMax),
FraudCode_MetadataOutputIndexOverflow)
}
// Verify HTLC Usage
function verifyHTLCData(blockHeader, input, utxoProof) {
/*
- Transaction UTXO Data:
- transactionHashId [32 bytes]
- outputIndex [32 bytes] -- padded uint8
- type [32 bytes] -- padded uint8
- amount [32 bytes]
- owner [32 bytes] -- padded address or unit8
- tokenID [32 bytes] -- padded uint32
- [HTLC Data]:
- digest [32 bytes]
- expiry [32 bytes] -- padded 4 bytes
- return witness index [32 bytes] -- padded 1 bytes
*/
// Select Transaction Input data
let length, utxoID, witnessReference, preImage := selectAndVerifyInputHTLC(input,
TransactionLengthMax)
// Select Transaction Block Height
let blockHeight := selectBlockHeight(blockHeader)
// Select Digest and Expiry from UTXO Proof (Assumed to be Valid)
let digest := load32(utxoProof, 6)
let expiry := load32(utxoProof, 7)
// If not expired, and digest correct, expired case gets handled in Comparison proofs
if lt(blockHeight, expiry) {
// Assert Digest is Valid
assertOrFraud(eq(digest, constructHTLCDigest(preImage)),
FraudCode_InvalidHTLCDigest)
}
}
// Verify Transaction Length (minimum and maximum)
function verifyTransactionLength(transactionLength) {
// Assert transaction length is not too short
assertOrFraud(gt(transactionLength, TransactionSizeMinimum),
FraudCode_TransactionLengthUnderflow)
// Assert transaction length is not too long
assertOrFraud(lte(transactionLength, TransactionSizeMaximum),
FraudCode_TransactionLengthOverflow)
}
// Verify Transaction Data (Metadata, Inputs, Outputs, Witnesses)
function verifyTransactionData(transactionData, utxoProofs) {
// Verify Transaction Length
verifyTransactionLength(selectTransactionLength(transactionData))
// Select and Verify Lengths and Use Them as Indexes (let Index = Length; lt; Index--)
let memoryPosition, inputsLength,
outputsLength, witnessesLength := selectAndVerifyTransactionDetails(transactionData)
// Memory Stack so we don't blow the stack!
mpush(Stack_InputsSum, 0) // Total Transaction Input Sum
mpush(Stack_OutputsSum, 0) // Total Transaction Output Sum
mpush(Stack_Metadata, selectTransactionMetadata(transactionData)) // Metadata Memory Position
mpush(Stack_Witnesses, selectTransactionWitnesses(transactionData)) // Witnesses Memory Position
mpush(Stack_BlockTip, getBlockTip()) // GET blockTip() from Storage
mpush(Stack_UTXOProofs, safeAdd(utxoProofs, mul32(1))) // UTXO Proofs Memory Position
mpush(Stack_TransactionHashID, constructTransactionHashID(transactionData)) // Construct Transaction Hash ID
mpush(Stack_MetadataLength, selectTransactionMetadataLength(transactionData))
// Push summing tokens
if gt(utxoProofs, 0) {
mpush(Stack_SummingToken, mload(utxoProofs)) // load summing token
mpush(Stack_SummingTokenID, getTokens(mload(utxoProofs))) // load summing token
}
// Set Block Header Position (on First Proof)
if iszero(mstack(Stack_ProofNumber)) {
// Proof 0 Block Header Position
mpush(Stack_BlockHeader, selectBlockHeader(FirstProof))
// Proof 0 Block Header Position
mpush(Stack_RootHeader, selectTransactionRoot(FirstProof))
// Return Stack Offset: (No Offset) First Transaction
mpush(Stack_SelectionOffset, 0)
// Proof 0 Transaction Root Producer
mpush(Stack_RootProducer, selectRootProducer(selectTransactionRoot(FirstProof)))
}
// If Second Transaction Processed, Set Block Header Position (On Second Proof)
if gt(mstack(Stack_ProofNumber), 0) {
// Proof 1 Block Header Position
mpush(Stack_BlockHeader, selectBlockHeader(SecondProof))
// Proof 0 Block Header Position
mpush(Stack_RootHeader, selectTransactionRoot(SecondProof))
// Return Stack Offset: Offset Memory Stack for Second Proof
mpush(Stack_SelectionOffset, SelectionStackOffsetSize) // 4 => Metadata, Input, Output, Witness Position
// Proof 1 Transaction Root Position
mpush(Stack_RootProducer, selectRootProducer(selectTransactionRoot(SecondProof)))
}
// Increase memory position past length Specifiers
memoryPosition := safeAdd(memoryPosition, TransactionLengthSize)
// Transaction Proof Stack Return
// 8) Metadata Tx 1, 9) Input Tx 1, 10) Output, 11) Witness Memory Position
// 12) Metadata Tx 2, 13) Input Tx 2, 14) Output, 15) Witness Memory Position
// VALIDATE Inputs Index from Inputs Length -> 0
for { mpush(Stack_Index, 0) }
lt(mstack(Stack_Index), inputsLength)
{ mpush(Stack_Index, safeAdd(mstack(Stack_Index), 1)) } {
// Check if This is Input Requested
if eq(mstack(Stack_Index), selectInputSelectionIndex(transactionData)) {
// Store Metadata Position in Stack
mpush(safeAdd(Stack_MetadataSelected, mstack(Stack_SelectionOffset)),
combineUint32(mstack(Stack_Metadata), memoryPosition, mstack(Stack_Index), 0))
}
// Select Input Type
switch selectInputType(memoryPosition)
case 0 { // InputType UTXO
// Increase Memory pointer
let length, utxoID, witnessReference := selectAndVerifyInputUTXO(memoryPosition,
witnessesLength)
// If UTXO/Deposit Proofs provided
if gt(utxoProofs, 0) {
let outputAmount, outputOwner,
tokenID := selectAndVerifyUTXOAmountOwner(mstack(Stack_UTXOProofs), 0, utxoID)
// Increase input sum
if eq(tokenID, mstack(Stack_SummingTokenID)) {
mpush(Stack_InputsSum, safeAdd(mstack(Stack_InputsSum), outputAmount))
}
// Increase UTXO proof memory position
mpush(Stack_UTXOProofs, safeAdd(mstack(Stack_UTXOProofs), UTXOProofSize))
// Verify transaction witness
verifyTransactionWitness(selectWitnessSignature(mstack(Stack_Witnesses), witnessReference),
mstack(Stack_TransactionHashID), outputOwner, mstack(Stack_RootProducer))
}
// cannot select metadata that does not exist
// assertOrFraud(lt(inputIndex, mstack(Stack_MetadataLength)),
// FraudCode_TransactionInputMetadataOverflow)
// Verify metadata for this input (metadata position, block tip)
verifyTransactionInputMetadata(mstack(Stack_BlockHeader), mstack(Stack_RootHeader),
mstack(Stack_Metadata), mstack(Stack_BlockTip), mstack(Stack_Index))
// Increase metadata memory position
mpush(Stack_Metadata, safeAdd(mstack(Stack_Metadata), MetadataSize))
// Push Input Length
mpush(safeAdd(Stack_SelectedInputLength, mstack(Stack_SelectionOffset)), length)
// increase Memory Position
memoryPosition := safeAdd(memoryPosition, length)
}
case 1 { // InputType DEPOSIT (verify deposit owner / details witnesses etc)
// Select Input Deposit (Asserts Deposit > 0)
let length, depositHashID,
witnessReference := selectAndVerifyInputDeposit(memoryPosition, witnessesLength)
// If UTXO Proofs provided
if gt(utxoProofs, 0) {
// Owner
let depositOwner := selectInputDepositOwner(mstack(Stack_UTXOProofs))
// Constructed Deposit hash
let constructedDepositHashID := constructDepositHashID(mstack(Stack_UTXOProofs))
// Check Deposit Hash ID against proof
assertOrInvalidProof(eq(depositHashID, constructedDepositHashID),
ErrorCode_InvalidDepositProof)
// Verify transaction witness
verifyTransactionWitness(selectWitnessSignature(mstack(Stack_Witnesses), witnessReference),
mstack(Stack_TransactionHashID), depositOwner, mstack(Stack_RootProducer))
// Deposit Token
let depositToken := selectInputDepositToken(mstack(Stack_UTXOProofs))
// Increase Input Amount
if eq(depositToken, mstack(Stack_SummingToken)) {
mpush(Stack_InputsSum, safeAdd(mstack(Stack_InputsSum), getDeposits(depositHashID)))
}
// Increase UTXO/Deposit proof memory position
mpush(Stack_UTXOProofs, safeAdd(mstack(Stack_UTXOProofs), DepositProofSize))
}
// Push Input Length
mpush(safeAdd(Stack_SelectedInputLength, mstack(Stack_SelectionOffset)), length)
// Increase Memory Position
memoryPosition := safeAdd(memoryPosition, length)
}
case 2 { // InputType HTLC
// Select HTLC Input
let length, utxoID, witnessReference, preImage := selectAndVerifyInputHTLC(
memoryPosition, witnessesLength)
// If UTXO Proofs provided
if gt(utxoProofs, 0) {
let outputAmount, outputOwner, tokenID := selectAndVerifyUTXOAmountOwner(
mstack(Stack_UTXOProofs), 2, utxoID)
// Verify HTLC Data
verifyHTLCData(mstack(Stack_BlockHeader), memoryPosition, mstack(Stack_UTXOProofs))
// Verify transaction witness
verifyTransactionWitness(selectWitnessSignature(mstack(Stack_Witnesses), witnessReference),
mstack(Stack_TransactionHashID), outputOwner, mstack(Stack_RootProducer))
// Increase input sum
if eq(tokenID, mstack(Stack_SummingTokenID)) {
mpush(Stack_InputsSum, safeAdd(mstack(Stack_InputsSum), outputAmount))
}
// Increase UTXO proof memory position
mpush(Stack_UTXOProofs, safeAdd(mstack(Stack_UTXOProofs), UTXOProofSize))
}
// Verify metadata for this input (metadata position, block tip)
verifyTransactionInputMetadata(mstack(Stack_BlockHeader), mstack(Stack_RootHeader),
mstack(Stack_Metadata), mstack(Stack_BlockTip), mstack(Stack_Index))
// Increase metadata memory position
mpush(Stack_Metadata, safeAdd(mstack(Stack_Metadata), MetadataSize))
// Push Input Length
mpush(safeAdd(Stack_SelectedInputLength, mstack(Stack_SelectionOffset)), length)
// Increase Memory Position
memoryPosition := safeAdd(memoryPosition, length)
}
case 3 { // InputType CHANGE UNSPENT
// HTLC input
let length, utxoID, witnessReference := selectAndVerifyInputUTXO(memoryPosition, witnessesLength)
// If UTXO Proofs provided
if gt(utxoProofs, 0) {
let outputAmount, outputOwner,
tokenID := selectAndVerifyUTXOAmountOwner(mstack(Stack_UTXOProofs),
OutputType_Change, utxoID)
// witness signatures get enforced in invalidTransactionInput
// Increase input sum
if eq(tokenID, mstack(Stack_SummingTokenID)) {
mpush(Stack_InputsSum, safeAdd(mstack(Stack_InputsSum), outputAmount))
}
// Increase UTXO proof memory position
mpush(Stack_UTXOProofs, safeAdd(mstack(Stack_UTXOProofs), UTXOProofSize))
}
// Verify metadata for this input (metadata position, block tip)
verifyTransactionInputMetadata(mstack(Stack_BlockHeader), mstack(Stack_RootHeader),
mstack(Stack_Metadata), mstack(Stack_BlockTip), mstack(Stack_Index))
// Increase metadata memory position
mpush(Stack_Metadata, safeAdd(mstack(Stack_Metadata), MetadataSize))
// Push Input Length
mpush(safeAdd(Stack_SelectedInputLength, mstack(Stack_SelectionOffset)), length)
// Increase Memory Position
memoryPosition := safeAdd(memoryPosition, length)
}
// Assert fraud Invalid Input Type
default { assertOrFraud(0, FraudCode_InvalidTransactionInputType) }
// Increase Memory Pointer for 1 byte Type
memoryPosition := safeAdd(memoryPosition, TypeSize)
}
// Index from Outputs Length -> 0
for { mpush(Stack_Index, 0) }
lt(mstack(Stack_Index), outputsLength)
{ mpush(Stack_Index, safeAdd(mstack(Stack_Index), 1)) } {
// Check if input is requested
if eq(mstack(Stack_Index), selectOutputSelectionIndex(transactionData)) {
// Store Output Memory Position in Stack
mpush(safeAdd(Stack_OutputSelected, mstack(Stack_SelectionOffset)), memoryPosition)
}
// Select Output Type
switch selectOutputType(memoryPosition)
case 0 { // OutputType UTXO
// Increase Memory pointer
let length, amount, owner, tokenID := selectAndVerifyOutput(memoryPosition, False)
// Increase total output sum
if eq(tokenID, mstack(Stack_SummingTokenID)) {
mpush(Stack_OutputsSum, safeAdd(mstack(Stack_OutputsSum), amount))
}
// Increase Memory pointer
memoryPosition := safeAdd(length, memoryPosition)
}
case 1 { // OutputType withdrawal
// Increase Memory pointer
let length, amount, owner, tokenID := selectAndVerifyOutput(memoryPosition, False)
// Increase total output sum
if eq(tokenID, mstack(Stack_SummingTokenID)) {
mpush(Stack_OutputsSum, safeAdd(mstack(Stack_OutputsSum), amount))
}
// Increase Memory pointer
memoryPosition := safeAdd(length, memoryPosition)
}
case 2 { // OutputType HTLC
// Increase Memory pointer
let length, amount, owner, tokenID,
digest, expiry, returnWitness := selectAndVerifyOutputHTLC(memoryPosition,
witnessesLength)
// Check expiry is greater than its own block header
assertOrFraud(gt(expiry, selectBlockHeight(mstack(Stack_BlockHeader))),
FraudCode_OutputHTLCExpiryUnderflow)
// Increase total output sum
if eq(tokenID, mstack(Stack_SummingTokenID)) {
mpush(Stack_OutputsSum, safeAdd(mstack(Stack_OutputsSum), amount))
}
// Increase Memory pointer
memoryPosition := safeAdd(length, memoryPosition)
}
case 3 { // OutputType CHANGE UNSPENT
// Increase Memory pointer
let length, amount, witnessReference,
tokenID := selectAndVerifyOutput(memoryPosition, True)
// Invalid Witness Reference out of bounds
assertOrFraud(lt(witnessReference, witnessesLength),
FraudCode_TransactionOutputWitnessReferenceOverflow)
// Increase total output sum
if eq(tokenID, mstack(Stack_SummingTokenID)) {
mpush(Stack_OutputsSum, safeAdd(mstack(Stack_OutputsSum), amount))
}
// Increase Memory pointer
memoryPosition := safeAdd(length, memoryPosition)
}
// Assert fraud Invalid Input Type
default { assertOrFraud(0, FraudCode_InvalidTransactionOutputType) }
// Increase Memory Pointer for 1 byte Type
memoryPosition := safeAdd(memoryPosition, TypeSize)
}
// Assert Transaction Total Output Sum <= Total Input Sum
if gt(utxoProofs, 0) { assertOrFraud(eq(mstack(Stack_OutputsSum), mstack(Stack_InputsSum)),
FraudCode_TransactionSumMismatch) }
// Iterate from Witnesses Length -> 0
for { mpush(Stack_Index, 0) }
lt(mstack(Stack_Index), witnessesLength)
{ mpush(Stack_Index, safeAdd(mstack(Stack_Index), 1)) } {
// check if input is requested
if eq(mstack(Stack_Index), selectWitnessSelectionIndex(transactionData)) {
// Store Witness Memory Position in Stack
mpush(safeAdd(Stack_WitnessSelected, mstack(Stack_SelectionOffset)),
mstack(Stack_Witnesses))
}
// Increase witness memory position
mpush(Stack_Witnesses, safeAdd(mstack(Stack_Witnesses), WitnessSize))
}
// Check Transaction Length for Validity based on Computed Lengths
// Get Leaf Size details
let unsignedTransactionData, metadataSize,
witnessesSize, witnessLength := selectAndVerifyTransactionLeafData(transactionData)
// Select Transaction Length
let transactionLength := selectTransactionLength(transactionData)
// Metadata size
let providedDataSize := add3(TransactionLengthSize, metadataSize, witnessesSize)
// We should never hit this, but we will add in the protection anyway..
assertOrFraud(lt(providedDataSize, transactionLength),
FraudCode_ProvidedDataOverflow)
// Memory size difference
let unsignedTransactionLength := safeSub(transactionLength, providedDataSize)
// We should never hit this, but we will add in the protection anyway..
assertOrFraud(lt(unsignedTransactionData, memoryPosition),
FraudCode_ProvidedDataOverflow)
// Computed unsigned transaction length
// Should never underflow
let computedUnsignedTransactionLength := safeSub(memoryPosition, unsignedTransactionData)
// Invalid transaction length
assertOrFraud(eq(unsignedTransactionLength, computedUnsignedTransactionLength),
FraudCode_ComputedTransactionLengthOverflow)
// Pop Memory Stack
mpop(Stack_InputsSum)
mpop(Stack_OutputsSum)
mpop(Stack_Metadata)
mpop(Stack_Witnesses)
mpop(Stack_BlockTip)
mpop(Stack_UTXOProofs)
mpop(Stack_TransactionHashID)
mpop(Stack_MetadataLength)
mpush(Stack_SummingToken, 0) // load summing token
mpush(Stack_SummingTokenID, 0) // load summing token
mpop(Stack_Index)
// We leave Memory Stack 6 for Secondary Transaction Proof Validation
// We don't clear 7 - 15 (those are the returns from transaction processing)
// Warning: CHECK Transaction Leaf Length here for Computed Length!!
}
mpop(Stack_Index)
//
// SELECTOR METHODS
// For selecting, parsing and enforcing side-chain abstractions, rules and data across runtime memory
//
// Select the UTXO ID for an Input
function selectUTXOID(input) -> utxoID {
// Past 1 (input type)
utxoID := mload(safeAdd(input, TypeSize))
}
// Select Metadata
function selectMetadata(metadata) -> blockHeight, transactionRootIndex,
transactionIndex, outputIndex {
blockHeight := slice(metadata, 4)
transactionRootIndex := slice(safeAdd(metadata, 4), IndexSize)
transactionIndex := slice(safeAdd(metadata, 5), 2)
outputIndex := slice(safeAdd(metadata, 7), IndexSize)
}
// Select Metadata Selected (Used after verifyTransactionData)
function selectInputSelectedHash(proofIndex) -> inputHash {
let offset := 0
// Second proof, move offset to 4
if gt(proofIndex, 0) { offset := SelectionStackOffsetSize }
// Input Hash Length (Type 1 Byte + Input Length Provided)
let inputHashLength := 0
// Input Memory Position
let input := selectInputSelected(proofIndex)
// Get lenght
switch selectInputType(input)
case 0 {
inputHashLength := 33
}
case 1 {
inputHashLength := 33
}
case 2 {
inputHashLength := 65
}
case 3 {
inputHashLength := 33
}
default { assertOrInvalidProof(0, 0) }
// Set metadata
inputHash := keccak256(input, inputHashLength)
}
// Select Metadata Selected (Used after verifyTransactionData)
function selectMetadataSelected(proofIndex) -> metadata {
let offset := 0
// Second proof, move offset to 4
if gt(proofIndex, 0) { offset := SelectionStackOffsetSize }
// Return metadata memory position
let metadataInput, input, unused,
unused2 := splitCombinedUint32(mstack(safeAdd(Stack_MetadataSelected, offset)))
// Set metadata
metadata := metadataInput
}
// Select Input Selected (Used after verifyTransactionData)
function selectInputSelected(proofIndex) -> input {
let offset := 0
// Second proof, move offset to 4
if gt(proofIndex, 0) { offset := SelectionStackOffsetSize }
// Get values
let metadata, inputPosition, unused,
unused2 := splitCombinedUint32(mstack(safeAdd(Stack_MetadataSelected, offset)))
// Input position
input := inputPosition
}
// Select Output Selected (Used after verifyTransactionData)
function selectOutputSelected(proofIndex) -> output {
let offset := 0
// Second proof, move offset to 4
if gt(proofIndex, 0) { offset := SelectionStackOffsetSize }
// Return metadata memory position
output := mstack(safeAdd(Stack_OutputSelected, offset))
}
// Select Witness Selected (Used after verifyTransactionData)
function selectWitnessSelected(proofIndex) -> witness {
let offset := 0
// Second proof, move offset to 4
if gt(proofIndex, 0) { offset := SelectionStackOffsetSize }
// Return metadata memory position
witness := mstack(safeAdd(Stack_WitnessSelected, offset))
}
function selectBlockHeaderLength(transactionProof) -> blockHeaderLength {
blockHeaderLength := load32(transactionProof, 0)
}
function selectTransactionRootLength(transactionProof) -> transactionRootLength {
transactionRootLength := load32(transactionProof, 1)
}
function selectMerkleProofLength(transactionProof) -> merkleProofLength {
merkleProofLength := load32(transactionProof, 2)
}
// Select Transaction Proof Lengths
function selectTransactionProofLengths(transactionProof) ->
lengthsLength,
blockHeaderLength,
transactionRootHeaderLength,
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength {
// Compute Proof Length or Lengths
lengthsLength := mul32(5)
// If malformed block proof
if iszero(selectProofType()) {
lengthsLength := mul32(3)
}
// Select Proof Lengths
blockHeaderLength := load32(transactionProof, 0)
transactionRootHeaderLength := load32(transactionProof, 1)
transactionMerkleLength := load32(transactionProof, 2)
transactionDataLength := load32(transactionProof, 3)
transactionUTXOLength := load32(transactionProof, 4)
}
// Select Transaction Proof Memory Position
function selectTransactionProof(proofIndex) -> transactionProof {
// Increase proof memory position for proof type (32 bytes)
transactionProof := safeAdd(Calldata_MemoryPosition, mul32(1))
// Select second proof instead!
if gt(proofIndex, 0) {
// Get lengths
let lengthsLength,
blockHeaderLength,
transactionRootHeaderLength,
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength := selectTransactionProofLengths(transactionProof)
// Secondary position
transactionProof := add4(
transactionProof, lengthsLength, blockHeaderLength,
add4(transactionRootHeaderLength, transactionMerkleLength,
transactionDataLength, transactionUTXOLength))
}
}
// Select Transaction Proof Block Header
function selectBlockHeader(proofIndex) -> blockHeader {
// Select Proof Memory Position
blockHeader := selectTransactionProof(proofIndex)
// If it's not the bond withdrawal
if lt(selectProofType(), 6) {
let lengthsLength,
blockHeaderLength,
transactionRootHeaderLength,
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength := selectTransactionProofLengths(blockHeader)
// Block header (always after lengths)
blockHeader := safeAdd(blockHeader, lengthsLength)
}
}
function selectBlockProducer(blockHeader) -> blockProducer {
blockProducer := load32(blockHeader, 0)
}
function selectBlockHeight(blockHeader) -> blockHeight {
blockHeight := load32(blockHeader, 2)
}
function selectPreviousBlockHash(blockHeader) -> previousBlockHash {
previousBlockHash := load32(blockHeader, 1)
}
function selectTransactionRootsLength(blockHeader) -> transactionRootsLength {
transactionRootsLength := load32(blockHeader, 5)
}
function selectEthereumBlockNumber(blockHeader) -> ethereumBlockNumber {
ethereumBlockNumber := load32(blockHeader, 3)
}
// Select Transaction Root from Proof
function selectTransactionRoot(proofIndex) -> transactionRoot {
// Select Proof Memory Position
let transactionProof := selectTransactionProof(proofIndex)
// Get lengths
let lengthsLength,
blockHeaderLength,
transactionRootHeaderLength,
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength := selectTransactionProofLengths(transactionProof)
// Select Transaction Root Position
transactionRoot := add3(transactionProof, lengthsLength, blockHeaderLength)
}
// Select Root Producer
function selectRootProducer(transactionRoot) -> rootProducer {
rootProducer := load32(transactionRoot, 0)
}
// Select Merkle Tree Root
function selectMerkleTreeRoot(transactionRoot) -> merkleTreeRoot {
merkleTreeRoot := load32(transactionRoot, 1)
}
// Select commitment hash from root
function selectCommitmentHash(transactionRoot) -> commitmentHash {
commitmentHash := load32(transactionRoot, 2)
}
// Select Transaction Root Index
function selectTransactionRootIndex(transactionRoot) -> transactionRootIndex {
transactionRootIndex := load32(transactionRoot, 3)
}
// Select Transaction Root from Proof
function selectTransactionMerkleProof(proofIndex) -> merkleProof {
// Select Proof Memory Position
merkleProof := selectTransactionProof(proofIndex)
// Get lengths
let lengthsLength,
blockHeaderLength,
transactionRootHeaderLength,
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength := selectTransactionProofLengths(merkleProof)
// Select Transaction Root Position
merkleProof := add4(merkleProof, lengthsLength,
blockHeaderLength, transactionRootHeaderLength)
}
// Select First Merkle Proof
function selectMerkleTreeBaseLeaf(merkleProof) -> leaf {
leaf := load32(merkleProof, 3)
}
// Select Opposite Transaction Leaf in Merkle Proof
function selectOppositeTransactionLeaf(merkleProof) -> oppositeTransactionLeaf {
oppositeTransactionLeaf := mload(merkleProof)
}
// Select Merkle Tree Height
function selectMerkleTreeHeight(merkleProof) -> merkleTreeHeight {
merkleTreeHeight := load32(merkleProof, 2)
}
// Select Merkle Tree Height
function selectMerkleTree(merkleProof) -> merkleTree {
merkleTree := safeAdd(merkleProof, mul32(3))
}
// Select Transaction Data from Proof
function selectTransactionData(proofIndex) -> transactionData {
// Select Proof Memory Position
let proofMemoryPosition := selectTransactionProof(proofIndex)
// Get lengths
let lengthsLength,
blockHeaderLength,
transactionRootHeaderLength,
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength := selectTransactionProofLengths(proofMemoryPosition)
// Select Transaction Data Position
transactionData := add4(proofMemoryPosition, lengthsLength,
blockHeaderLength, safeAdd(transactionRootHeaderLength, transactionMerkleLength))
}
function selectTransactionIndex(transactionData) -> transactionIndex {
transactionIndex := load32(transactionData, 3)
}
function selectInputIndex(transactionData) -> outputIndex {
outputIndex := load32(transactionData, 0)
}
function selectOutputIndex(transactionData) -> outputIndex {
outputIndex := load32(transactionData, 1)
}
function selectWitnessIndex(transactionData) -> outputIndex {
outputIndex := load32(transactionData, 2)
}
// Verify Transaction Lengths
function verifyTransactionProofLengths(proofCount) {
// Total Proof Length
let proofLengthWithoutType := 0
// Iterate and Compute Maximum length
for { let proofIndex := 0 }
and(lt(proofIndex, 2), lt(proofIndex, proofCount))
{ proofIndex := safeAdd(proofIndex, 1) } {
// Get lengths
let lengthsLength,
blockHeaderLength,
transactionRootHeaderLength,
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength := selectTransactionProofLengths(selectTransactionProof(proofIndex))
// Add total proof length
proofLengthWithoutType := add4(add4(proofLengthWithoutType,
lengthsLength,
blockHeaderLength,
transactionRootHeaderLength),
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength)
}
// Verify Proof Length Overflow
verifyProofLength(proofLengthWithoutType)
}
// Select Transaction Data from Proof
function selectTransactionUTXOProofs(proofIndex) -> utxoProofs {
// Select Proof Memory Position
let proofMemoryPosition := selectTransactionProof(proofIndex)
// Get lengths
let lengthsLength,
blockHeaderLength,
transactionRootHeaderLength,
transactionDataLength,
transactionMerkleLength,
transactionUTXOLength := selectTransactionProofLengths(proofMemoryPosition)
// Select Transaction Data Position
utxoProofs := safeAdd(selectTransactionData(proofIndex), transactionDataLength)
}
function selectWithdrawalToken(proofIndex) -> withdrawalToken {
withdrawalToken := load32(selectTransactionUTXOProofs(proofIndex), 0)
}
// select proof type
function selectProofType() -> proofType {
proofType := load32(Calldata_MemoryPosition, 0) // 32 byte chunk
}
// Select input
function selectInputType(input) -> result {
result := slice(input, 1) // [1 bytes]
}
// Select utxoID (length includes type)
function selectAndVerifyInputUTXO(input, witnessesLength) -> length, utxoID, witnessReference {
utxoID := mload(safeAdd(1, input))
witnessReference := slice(add3(TypeSize, 32, input), IndexSize)
length := 33 // UTXO + Witness Reference
// Assert Witness Index is Valid
assertOrFraud(lt(witnessReference, witnessesLength),
FraudCode_TransactionInputWitnessReferenceOverflow)
}
// Select Input Deposit Proof
function selectInputDepositOwner(depositProof) -> owner {
// Load owner
owner := load32(depositProof, 0)
}
// Select Input Deposit Proof
function selectInputDepositToken(depositProof) -> token {
// Load owner
token := load32(depositProof, 1)
}
// Select deposit information (length includes type)
function selectAndVerifyInputDeposit(input, witnessesLength) -> length,
depositHashID, witnessReference {
depositHashID := mload(safeAdd(input, TypeSize))
witnessReference := slice(add3(input, TypeSize, 32), IndexSize)
length := 33
// Assert deposit is not zero
assertOrFraud(gt(getDeposits(depositHashID), 0), FraudCode_TransactionInputDepositZero)
// Assert Witness Index is Valid
assertOrFraud(lt(witnessReference, witnessesLength),
FraudCode_TransactionInputDepositWitnessOverflow)
}
// Select HTLC information (length includes type)
function selectAndVerifyInputHTLC(input, witnessesLength) -> length, utxoID,
witnessReference, preImage {
utxoID := mload(safeAdd(input, TypeSize))
witnessReference := slice(add3(input, TypeSize, 32), IndexSize)
preImage := mload(add4(input, TypeSize, 32, IndexSize))
length := 65
// Assert valid Witness Reference (could be changed to generic witness ref overflow later..)
assertOrFraud(lt(witnessReference, witnessesLength),
FraudCode_TransactionHTLCWitnessOverflow)
}
// Select output type
function selectOutputType(output) -> result {
result := slice(output, TypeSize) // [1 bytes]
}
// Select output amounts length (length includes type)
function selectAndVerifyOutputAmountLength(output) -> length {
// Select amounts length past Input Type
length := slice(safeAdd(TypeSize, output), 1)
// Assert amounts length greater than zero
assertOrFraud(gt(length, 0), FraudCode_TransactionOutputAmountLengthUnderflow)
// Assert amounts length less than 33 (i.e 1 <> 32)
assertOrFraud(lte(length, 32), FraudCode_TransactionOutputAmountLengthOverflow)
}
// Select output utxo (length includes type)
function selectAndVerifyOutput(output, isChangeOutput) -> length, amount, owner, tokenID {
let amountLength := selectAndVerifyOutputAmountLength(output)
// Push amount
amount := slice(add3(TypeSize, 1, output), amountLength) // 1 for Type, 1 for Amount Length
// owner dynamic length
let ownerLength := 20
// is Change output, than owner is witness reference
if eq(isChangeOutput, 1) {
ownerLength := 1
}
// Push owner
owner := slice(add4(TypeSize, 1, amountLength, output), ownerLength)
// Select Token ID
tokenID := slice(add4(TypeSize, 1, amountLength, safeAdd(ownerLength, output)), 4)
// Assert Token ID is Valid
assertOrFraud(lt(tokenID, getNumTokens()), FraudCode_TransactionOutputTokenIDOverflow)
// Push Output Length (don't include type size)
length := add4(TypeSize, amountLength, ownerLength, 4)
}
// Select output HTLC
function selectAndVerifyOutputHTLC(output, witnessesLength) -> length, amount, owner,
tokenID, digest, expiry, returnWitness {
// Select amount length
let amountLength := selectAndVerifyOutputAmountLength(output)
// Select Output Details
length, amount, owner, tokenID := selectAndVerifyOutput(output, False)
// htlc
let htlc := add3(TypeSize, output, length)
// Select Digest from Output
digest := mload(htlc)
// Assert Token ID is Valid
assertOrFraud(gt(digest, 0), FraudCode_TransactionOutputHTLCDigestZero)
// Select Expiry
expiry := slice(safeAdd(htlc, DigestSize), ExpirySize)
// Assert Expiry is Valid
assertOrFraud(gt(expiry, 0), FraudCode_TransactionOutputHTLCExpiryZero)
// Set expiry, digest, witness
returnWitness := slice(add3(htlc, DigestSize, ExpirySize), IndexSize)
// Assert Valid Return Witness
assertOrFraud(lt(returnWitness, witnessesLength),
FraudCode_TransactionOutputWitnessReferenceOverflow)
// Determine output length (don't include type size)
length := add4(length, DigestSize, ExpirySize, IndexSize)
}
// Select the Transaction Leaf from Data
function selectTransactionLeaf(transactionData) -> leaf {
/*
- Transaction Data:
- inputSelector [32 bytes]
- outputSelector [32 bytes]
- witnessSelector [32 bytes]
- transactionIndex [32 bytes]
- transactionLeafData [dynamic bytes]
*/
// Increase memory past the 3 selectors and 1 Index
leaf := safeAdd(transactionData, mul32(6))
}
// Select transaction length
function selectTransactionLength(transactionData) -> transactionLength {
// Select transaction length
transactionLength := slice(selectTransactionLeaf(transactionData), 2)
}
// Select Metadata Length
function selectTransactionMetadataLength(transactionData) -> metadataLength {
// Select metadata length 1 bytes
metadataLength := slice(safeAdd(selectTransactionLeaf(transactionData), 2), 1)
}
// Select Witnesses (past witness length)
function selectTransactionWitnesses(transactionData) -> witnessesMemoryPosition {
// Compute metadata size
let metadataLength := selectTransactionMetadataLength(transactionData)
// Compute Metadata Size
let metadataSize := safeAdd(TypeSize, safeMul(MetadataSize, metadataLength)) // Length + metadata size
// Leaf + Size 2 + metadata size and witness size
witnessesMemoryPosition := add4(selectTransactionLeaf(transactionData), 2,
metadataSize, 1)
}
function selectWitnessSignature(witnesses, witnessIndex) -> signature {
// Compute witness offset
let witnessMemoryOffset := safeMul(witnessIndex, WitnessSize)
// Compute signature
signature := safeAdd(witnesses, witnessMemoryOffset)
}
// Note, we allow the transactionRootProducer to be a witness, witnesses length must be 1, zero fill 65 for witness data..
// Select Witnesses Signature
function verifyTransactionWitness(signature, transactionHashID, outputOwner, rootProducer) {
// Check if the witness is not the transaction root producer (i.e. a contract possibly)
if iszero(eq(rootProducer, outputOwner)) {
// Assert if witness signature is invalid!
assertOrFraud(eq(outputOwner, ecrecoverPacked(transactionHashID, signature)),
FraudCode_InvalidTransactionWitnessSignature)
}
}
// Select Transaction Leaf Data
function selectAndVerifyTransactionLeafData(transactionData) ->
transactionHashData, // transaction hash data (unsigned transaction data)
metadataSize, // total metadata chunk size (length + metadata)
witnessesSize, // total witness size (length + witnesses)
witnessesLength { // total witnesses length
// Compute metadata size
let metadataLength := selectTransactionMetadataLength(transactionData)
// Assert metadata length correctness (metadata length can be zero)
assertOrFraud(lte(metadataLength, TransactionLengthMax),
FraudCode_TransactionMetadataLengthOverflow)
// Compute Metadata Size
metadataSize := safeAdd(1, safeMul(MetadataSize, metadataLength)) // Length + metadata size
// Leaf + Size 2 + metadata size and witness size
transactionHashData := add3(selectTransactionLeaf(transactionData), 2, metadataSize)
// get witnesses length
witnessesLength := slice(transactionHashData, 1) // Witness Length
witnessesSize := safeAdd(1, safeMul(WitnessSize, witnessesLength)) // Length + witness size
// Leaf + Size 2 + metadata size and witness size
transactionHashData := safeAdd(transactionHashData, witnessesSize)
}
// Select Transaction Details
function selectAndVerifyTransactionDetails(transactionData) ->
memoryPosition, inputsLength, outputsLength, witnessesLength {
let unsignedTransactionData, metadataSize,
witnessesSize, witnessLength := selectAndVerifyTransactionLeafData(transactionData)
// Setup length (push to new name)
witnessesLength := witnessLength
// Set Transaction Data Memory Position
memoryPosition := unsignedTransactionData
// Assert witness length
assertOrFraud(gt(witnessesLength, TransactionLengthMin),
FraudCode_TransactionWitnessesLengthUnderflow)
assertOrFraud(lte(witnessesLength, TransactionLengthMax),
FraudCode_TransactionWitnessesLengthOverflow)
// Select lengths
inputsLength := slice(memoryPosition, 1) // Inputs Length
outputsLength := slice(safeAdd(1, memoryPosition), 1) // Outputs Length
// Assert inputsLength and outputsLength minimum
assertOrFraud(gt(inputsLength, TransactionLengthMin),
FraudCode_TransactionInputsLengthUnderflow)
assertOrFraud(gt(outputsLength, TransactionLengthMin),
FraudCode_TransactionOutputsLengthUnderflow)
// Assert Length overflow checks
assertOrFraud(lte(inputsLength, TransactionLengthMax),
FraudCode_TransactionInputsLengthOverflow)
assertOrFraud(lte(outputsLength, TransactionLengthMax),
FraudCode_TransactionOutputsLengthOverflow)
// Assert metadata length correctness (metadata length can be zero)
assertOrFraud(lte(selectTransactionMetadataLength(transactionData), inputsLength),
FraudCode_TransactionMetadataLengthOverflow)
// Assert selections are valid against lengths
assertOrInvalidProof(lt(selectInputSelectionIndex(transactionData), inputsLength),
ErrorCode_InputIndexSelectedOverflow)
assertOrInvalidProof(lt(selectOutputSelectionIndex(transactionData), outputsLength),
ErrorCode_OutputIndexSelectedOverflow)
assertOrInvalidProof(lt(selectWitnessSelectionIndex(transactionData), witnessesLength),
ErrorCode_WitnessIndexSelectedOverflow)
}
// Select Transaction Metadata (Past Length)
function selectTransactionMetadata(transactionData) -> transactionMetadata {
// Increase memory position past lengths
transactionMetadata := safeAdd(selectTransactionLeaf(transactionData), 3)
}
// Select UTXO proof
function selectAndVerifyUTXOAmountOwner(utxoProof, requestedOutputType, providedUTXOID) ->
outputAmount, outputOwner, tokenID {
/*
- Transaction UTXO Proof(s): -- 288 bytes (same order as inputs, skip Deposit index with zero fill)
- transactionHashId [32 bytes] -- bytes32
- outputIndex [32 bytes] -- padded uint8
- type [32 bytes] -- padded uint8
- amount [32 bytes] -- uint256
- owner [32 bytes] -- padded address or witness reference index uint8
- tokenID [32 bytes] -- padded uint32
- [HTLC Data]:
- digest [32 bytes] -- bytes32 (or zero pad 32 bytes)
- expiry [32 bytes] -- padded uint32 (or zero pad 32 bytes)
- return witness index [32 bytes] -- padded uint8] (or zero pad 32 bytes)
*/
// Assert computed utxo id correct
assertOrInvalidProof(eq(providedUTXOID, constructUTXOID(utxoProof)),
ErrorCode_TransactionUTXOIDInvalid)
// Compute output amount
let outputType := load32(utxoProof, 2)
// Assert output type is correct
assertOrFraud(eq(requestedOutputType, outputType),
FraudCode_TransactionUTXOType)
// Assert index correctness
assertOrFraud(lt(load32(utxoProof, 1), TransactionLengthMax),
FraudCode_TransactionUTXOOutputIndexOverflow)
// Compute output amount
outputAmount := load32(utxoProof, 3)
// Compute output amount
outputOwner := load32(utxoProof, 4)
// Compute output amount
tokenID := load32(utxoProof, 5)
}
//
// CONSTRUCTION METHODS
// For the construction of cryptographic side-chain hashes
//
// produce block hash from block header
function constructBlockHash(blockHeader) -> blockHash {
/*
- Block Header:
- blockProducer [32 bytes] -- padded address
- previousBlockHash [32 bytes]
- blockHeight [32 bytes]
- ethereumBlockNumber [32 bytes]
- transactionRoots [64 + bytes32 array]
*/
// Select Transaction root Length
let transactionRootsLength := load32(blockHeader, 5)
// Construct Block Hash
blockHash := keccak256(blockHeader, mul32(safeAdd(6, transactionRootsLength)))
}
// produce a transaction hash id from a proof (subtract metadata and inputs length from hash data)
function constructTransactionHashID(transactionData) -> transactionHashID {
/*
- Transaction Data:
- inputSelector [32 bytes]
- outputSelector [32 bytes]
- witnessSelector [32 bytes]
- transactionIndex [32 bytes]
- transactionLeafData [dynamic bytes]
- Transaction Leaf Data:
- transactionByteLength [2 bytes] (max 2048)
- metadata length [1 bytes] (min 1 - max 8)
- input metadata [dynamic -- 8 bytes per]:
- blockHeight [4 bytes]
- transactionRootIndex [1 byte]
- transactionIndex [2 bytes]
- output index [1 byte]
- witnessLength [1 bytes]
- witnesses [dynamic]:
- signature [65 bytes]
*/
// Get entire tx length, and metadata sizes / positions
let transactionLength := selectTransactionLength(transactionData) // length is first 2
if gt(transactionLength, 0) {
let transactionLeaf, metadataSize,
witnessesSize, witnessLength := selectAndVerifyTransactionLeafData(transactionData)
// setup hash keccak256(start, length)
let transactionHashDataLength := safeSub(safeSub(transactionLength, TransactionLengthSize),
safeAdd(metadataSize, witnessesSize))
// create transaction ID
transactionHashID := keccak256(transactionLeaf, transactionHashDataLength)
}
}
// Construct Deposit Hash ID
function constructDepositHashID(depositProof) -> depositHashID {
depositHashID := keccak256(depositProof, mul32(3))
}
// Construct a UTXO Proof from a Transaction Output
function constructUTXOProof(transactionHashID, outputIndex, output) -> utxoProof {
let isChangeOutput := False
// Output Change
if eq(selectOutputType(output), OutputType_Change) {
isChangeOutput := True
}
// Select and Verify output
let length, amount, owner, tokenID := selectAndVerifyOutput(output, isChangeOutput)
// Encode Pack Transaction Output Data
mstore(mul32(1), transactionHashID)
mstore(mul32(2), outputIndex)
mstore(mul32(3), selectOutputType(output))
mstore(mul32(4), amount)
mstore(mul32(5), owner) // address or witness index
mstore(mul32(6), tokenID)
mstore(mul32(7), 0)
mstore(mul32(8), 0)
mstore(mul32(9), 0)
// Include HTLC Data here
if eq(selectOutputType(output), 2) {
let unused0, unused1, unused2,
unused3, digest, expiry, returnWitness := selectAndVerifyOutputHTLC(output,
TransactionLengthMax)
mstore(mul32(7), digest)
mstore(mul32(8), expiry)
mstore(mul32(9), returnWitness)
}
// Return UTXO Memory Position
utxoProof := mul32(1)
}
// Construct a UTXO ID
function constructUTXOID(utxoProof) -> utxoID {
/*
- Transaction UTXO Data:
- transactionHashId [32 bytes]
- outputIndex [32 bytes] -- padded uint8
- type [32 bytes] -- padded uint8
- amount [32 bytes]
- owner [32 bytes] -- padded address or unit8
- tokenID [32 bytes] -- padded uint32
- [HTLC Data]: -- padded with zeros
- digest [32 bytes]
- expiry [32 bytes] -- padded 4 bytes
- return witness index [32 bytes] -- padded 1 bytes
*/
// Construct UTXO ID
utxoID := keccak256(utxoProof, UTXOProofSize)
}
// Construct the Transaction Leaf Hash
function constructTransactionLeafHash(transactionData) -> transactionLeafHash {
/*
- Transaction Data:
- inputSelector [32 bytes]
- outputSelector [32 bytes]
- witnessSelector [32 bytes]
- transactionIndex [32 bytes]
- transactionLeafData [dynamic bytes]
*/
// Get first two transaction length bytes
let transactionLength := selectTransactionLength(transactionData)
// Check if length is Zero, than don't hash!
switch eq(transactionLength, 0)
// Return Zero leaf hash
case 1 {
transactionLeafHash := 0
}
// Hash as Normal Transaction
default {
// Start Hash Past Selections (3) and Index (1)
let hashStart := selectTransactionLeaf(transactionData)
// Return the transaction leaf hash
transactionLeafHash := keccak256(hashStart, transactionLength)
}
}
// Select input index
function selectInputSelectionIndex(transactionData) -> inputIndex {
inputIndex := load32(transactionData, 0)
}
// Select output index
function selectOutputSelectionIndex(transactionData) -> outputIndex {
outputIndex := load32(transactionData, 1)
}
// Select witness index
function selectWitnessSelectionIndex(transactionData) -> witnessIndex {
witnessIndex := load32(transactionData, 2)
}
// This function Must Select Block of Current Proof Being Validated!! NOT DONE YET!
// Assert True or Fraud, Set Side-chain to Valid block and Stop Execution
function assertOrFraud(assertion, fraudCode) {
// Assert or Begin Fraud State Change Sequence
if lt(assertion, 1) {
// proof index
let proofIndex := 0
// We are validating proof 2
if gt(mstack(Stack_ProofNumber), 0) {
proofIndex := 1
}
// Fraud block details
let fraudBlockHeight := selectBlockHeight(selectBlockHeader(proofIndex))
let fraudBlockProducer := selectBlockProducer(selectBlockHeader(proofIndex))
let ethereumBlockNumber := selectEthereumBlockNumber(selectBlockHeader(proofIndex))
// Assert Fraud block cannot be the genesis block
assertOrInvalidProof(gt(fraudBlockHeight, GenesisBlockHeight),
ErrorCode_FraudBlockHeightUnderflow)
// Assert fraud block cannot be finalized
assertOrInvalidProof(lt(number(), safeAdd(ethereumBlockNumber, FINALIZATION_DELAY)),
ErrorCode_FraudBlockFinalized)
// Push old block tip
let previousBlockTip := getBlockTip()
// Set new block tip to before fraud block
setBlockTip(safeSub(fraudBlockHeight, 1))
// Release Block Producer, If it's Permissioned
// (i.e. block producer committed fraud so get them out!)
// if eq(fraudBlockProducer, getBlockProducer()) {
// setBlockProducer(0)
// }
// Log block tips (old / new)
log4(0, 0, FraudEventTopic, previousBlockTip, getBlockTip(),
fraudCode)
// Transfer Half The Bond for this Block
transfer(div(BOND_SIZE, 2), EtherToken, EtherToken, caller())
// stop execution from here
stop()
}
}
// Construct withdrawal Hash ID
function constructWithdrawalHashID(transactionRootIndex,
transactionLeafHash, outputIndex) -> withdrawalHashID {
// Construct withdrawal Hash
mstore(mul32(1), transactionRootIndex)
mstore(mul32(2), transactionLeafHash)
mstore(mul32(3), outputIndex)
// Hash Leaf and Output Together
withdrawalHashID := keccak256(mul32(1), mul32(3))
}
// Construct Transactions Merkle Tree Root
function constructMerkleTreeRoot(transactions, transactionsLength) -> merkleTreeRoot {
// Start Memory Position at Transactions Data
let memoryPosition := transactions
let nodesLength := 0
let netLength := 0
let freshMemoryPosition := mstack(Stack_FreshMemory)
// create base hashes and notate node count
for { let transactionIndex := 0 }
lt(transactionIndex, MaxTransactionsInBlock)
{ transactionIndex := safeAdd(transactionIndex, 1) } {
// get the transaction length
let transactionLength := slice(memoryPosition, TransactionLengthSize)
// If Transaction length is zero and we are past first tx, stop (we are at the end)
if and(gt(transactionIndex, 0), iszero(transactionLength)) { break }
// if transaction length is below minimum transaction length, stop
verifyTransactionLength(transactionLength)
// add net length together
netLength := safeAdd(netLength, transactionLength)
// computed length greater than provided payload
assertOrFraud(lte(netLength, transactionsLength),
FraudCode_InvalidTransactionsNetLength)
// store the base leaf hash (add 2 removed from here..)
mstore(freshMemoryPosition, keccak256(memoryPosition, transactionLength))
// increase the memory length
memoryPosition := safeAdd(memoryPosition, transactionLength)
// increase fresh memory by 32 bytes
freshMemoryPosition := safeAdd(freshMemoryPosition, 32)
// increase number of nodes
nodesLength := safeAdd(nodesLength, 1)
}
// computed length greater than provided payload
assertOrFraud(eq(netLength, transactionsLength), FraudCode_InvalidTransactionsNetLength)
// Merkleize nodes into a binary merkle tree
memoryPosition := safeSub(freshMemoryPosition, safeMul(nodesLength, 32)) // setup new memory position
// Create Binary Merkle Tree / Master Root Hash
for {} gt(nodesLength, 0) {} { // loop through tree Heights (starting at base)
if gt(mod(nodesLength, 2), 0) { // fix uneven leaf count (i.e. add a zero hash)
mstore(safeAdd(memoryPosition, safeMul(nodesLength, 32)), 0) // add 0x00...000 hash leaf
nodesLength := safeAdd(nodesLength, 1) // increase count for zero hash leaf
freshMemoryPosition := safeAdd(freshMemoryPosition, 32) // increase fresh memory past new leaf
}
for { let i := 0 } lt(i, nodesLength) { i := safeAdd(i, 2) } { // loop through Leaf hashes at this height
mstore(freshMemoryPosition, keccak256(safeAdd(memoryPosition, safeMul(i, 32)), 64)) // hash two leafs together
freshMemoryPosition := safeAdd(freshMemoryPosition, 32) // increase fresh memory past new hash leaf
}
memoryPosition := safeSub(freshMemoryPosition, safeMul(nodesLength, 16)) // set new memory position
nodesLength := div(nodesLength, 2) // half nodes (i.e. next height)
// shim 1 to zero (stop), i.e. top height end..
if lt(nodesLength, 2) { nodesLength := 0 }
}
// merkle root has been produced
merkleTreeRoot := mload(memoryPosition)
// write new fresh memory position
mpush(Stack_FreshMemory, safeAdd(freshMemoryPosition, mul32(2)))
}
// Construct HTLC Digest Hash
function constructHTLCDigest(preImage) -> digest {
// Store PreImage in Memory
mstore(mul32(1), preImage)
// Construct Digest Hash
digest := keccak256(mul32(1), mul32(1))
}
//
// LOW LEVEL METHODS
//
// Safe Math Add
function safeAdd(x, y) -> z {
z := add(x, y)
assertOrInvalidProof(or(eq(z, x), gt(z, x)), ErrorCode_SafeMathAdditionOverflow) // require((z = x + y) >= x, "ds-math-add-overflow");
}
// Safe Math Subtract
function safeSub(x, y) -> z {
z := sub(x, y)
assertOrInvalidProof(or(eq(z, x), lt(z, x)), ErrorCode_SafeMathSubtractionUnderflow) // require((z = x - y) <= x, "ds-math-sub-underflow");
}
// Safe Math Multiply
function safeMul(x, y) -> z {
if gt(y, 0) {
z := mul(x, y)
assertOrInvalidProof(eq(div(z, y), x), ErrorCode_SafeMathMultiplyOverflow) // require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
}
// Safe Math Add3, Add4 Shorthand
function add3(x, y, z) -> result {
result := safeAdd(x, safeAdd(y, z))
}
function add4(x, y, z, k) -> result {
result := safeAdd(x, safeAdd(y, safeAdd(z, k)))
}
// Common <= and >=
function lte(v1, v2) -> result {
result := or(lt(v1, v2), eq(v1, v2))
}
function gte(v1, v2) -> result {
result := or(gt(v1, v2), eq(v1, v2))
}
// Safe Multiply by 32
function mul32(length) -> result {
result := safeMul(32, length)
}
// function combine 3 unit32 values together into one 32 byte combined value
function combineUint32(val1, val2, val3, val4) -> combinedValue {
mstore(safeAdd(mul32(2), 8), val4) // 2 bytes
mstore(safeAdd(mul32(2), 6), val3) // 2 bytes
mstore(safeAdd(mul32(2), 4), val2) // 2 bytes
mstore(safeAdd(mul32(2), 2), val1) // 2 bytes
// Grab combined value
combinedValue := mload(mul32(3))
}
// split a combined value into three original chunks
function splitCombinedUint32(combinedValue) -> val1, val2, val3, val4 {
mstore(mul32(2), combinedValue)
// grab values
val1 := slice(safeAdd(mul32(2), 0), 2) // 2 byte slice
val2 := slice(safeAdd(mul32(2), 2), 2) // 2 byte slice
val3 := slice(safeAdd(mul32(2), 4), 2) // 2 byte slice
val3 := slice(safeAdd(mul32(2), 6), 2) // 2 byte slice
}
// Transfer method helper
function transfer(amount, tokenID, token, owner) {
// Assert value owner / amount
assertOrInvalidProof(gt(amount, 0), ErrorCode_TransferAmountUnderflow)
assertOrInvalidProof(gt(owner, 0), ErrorCode_TransferOwnerInvalid)
// Assert valid token ID
assertOrInvalidProof(lt(tokenID, getNumTokens()), ErrorCode_TransferTokenIDOverflow)
// Assert address is properly registered token
assertOrInvalidProof(eq(tokenID, getTokens(token)), ErrorCode_TransferTokenAddress)
// Ether Token
if eq(token, EtherToken) {
let result := call(owner, 21000, amount, 0, 0, 0, 0)
assertOrInvalidProof(result, ErrorCode_TransferEtherCallResult)
}
// ERC20 "a9059cbb": "transfer(address,uint256)",
if gt(token, 0) {
// Construct ERC20 Transfer
mstore(mul32(1), 0xa9059cbb)
mstore(mul32(2), owner)
mstore(mul32(3), amount)
// Input Details
let inputStart := safeAdd(mul32(1), 28)
let inputLength := 68
// ERC20 Call
let result := call(token, 400000, 0, inputStart, inputLength, 0, 0)
assertOrInvalidProof(result, ErrorCode_TransferERC20Result)
}
}
// Virtual Memory Stack Push (for an additional 32 stack positions)
function mpush(pos, val) { // Memory Push
mstore(add(Stack_MemoryPosition, mul32(pos)), val)
}
// Virtual Memory Stack Get
function mstack(pos) -> result { // Memory Stack
result := mload(add(Stack_MemoryPosition, mul32(pos)))
}
// Virtual Stack Pop
function mpop(pos) { // Memory Pop
mstore(add(Stack_MemoryPosition, mul32(pos)), 0)
}
// Memory Slice (within a 32 byte chunk)
function slice(position, length) -> result {
if gt(length, 32) { revert(0, 0) } // protect against overflow
result := div(mload(position), exp(2, safeSub(256, safeMul(length, 8))))
}
// Solidity Storage Key: mapping(bytes32 => bytes32)
function mappingStorageKey(key, storageIndex) -> storageKey {
mstore(32, key)
mstore(64, storageIndex)
storageKey := keccak256(32, 64)
}
// Solidity Storage Key: mapping(bytes32 => mapping(bytes32 => bytes32)
function mappingStorageKey2(key, key2, storageIndex) -> storageKey {
mstore(32, key)
mstore(64, storageIndex)
mstore(96, key2)
mstore(128, keccak256(32, 64))
storageKey := keccak256(96, 64)
}
// load a 32 byte chunk with a 32 byte offset chunk from position
function load32(memoryPosition, chunkOffset) -> result {
result := mload(add(memoryPosition, safeMul(32, chunkOffset)))
}
// Assert True or Invalid Proof
function assertOrInvalidProof(arg, errorCode) {
if lt(arg, 1) {
// Set Error Code In memory
mstore(mul32(1), errorCode)
// Revert and Return Error Code
revert(mul32(1), mul32(1))
// Just incase we add a stop
stop()
}
}
// ECRecover Helper: hashPosition (32 bytes), signaturePosition (65 bytes) tight packing VRS
function ecrecoverPacked(digestHash, signatureMemoryPosition) -> account {
mstore(32, digestHash) // load in hash
mstore(64, 0) // zero pas
mstore(95, mload(signatureMemoryPosition))
mstore(96, mload(safeAdd(signatureMemoryPosition, 1)))
mstore(128, mload(safeAdd(signatureMemoryPosition, 33)))
let result := call(3000, 1, 0, 32, 128, 128, 32) // 4 chunks, return at 128
if eq(result, 0) { revert(0, 0) }
account := mload(128) // set account
}
//
// SETTERS & GETTER METHODS
// Solidity setters and getters for side-chain state storage
//
// GET mapping(bytes32 => uint256) public deposits; // STORAGE 0
function getDeposits(depositHashId) -> result {
result := sload(mappingStorageKey(depositHashId, Storage_deposits))
}
// GET mapping(uint256 => mapping(bytes32 => bool)) publica withdrawals; // STORAGE 1
function getWithdrawals(blockHeight, withdrawalHashID) -> result {
result := sload(mappingStorageKey2(blockHeight, withdrawalHashID, Storage_withdrawals))
}
// SET mapping(uint256 => mapping(bytes32 => bool)) publica withdrawals; // STORAGE 1
function setWithdrawals(blockHeight, withdrawalHashID, hasWithdrawn) {
sstore(mappingStorageKey2(blockHeight, withdrawalHashID, Storage_withdrawals), hasWithdrawn)
}
// GET mapping(bytes32 => uint256) public blockTransactionRoots; // STORAGE 2
function getBlockTransactionRoots(transactionRoot) -> result {
result := sload(mappingStorageKey(transactionRoot, Storage_blockTransactionRoots))
}
// GET mapping(uint256 => bytes32) public blockCommitments; // STORAGE 3
function getBlockCommitments(blockHeight) -> result {
result := sload(mappingStorageKey(blockHeight, Storage_blockCommitments))
}
// GET mapping(address => uint256) public tokens; // STORAGE 4
function getTokens(tokenAddress) -> result {
result := sload(mappingStorageKey(tokenAddress, Storage_tokens))
// Ether token should always be zero
if eq(tokenAddress, 0) {
assertOrInvalidProof(eq(result, 0), ErrorCode_InvalidTokenAddress)
}
// ERC20 should always be above zero
if gt(tokenAddress, 0) {
assertOrInvalidProof(gt(result, 0), ErrorCode_InvalidTokenAddress)
}
}
// GET uint256 public numTokens; // STORAGE 5
function getNumTokens() -> result {
result := sload(Storage_numTokens)
}
// SET uint256 public blockTip; // STORAGE 6
function getBlockTip() -> result {
result := sload(Storage_blockTip)
}
// SET blockTip() // STORAGE 6
function setBlockTip(tip) {
sstore(Storage_blockTip, tip)
}
// GET address public blockProducer; // STORAGE 7
function getBlockProducer() -> result {
result := sload(Storage_blockProducer)
}
// SET address public blockProducer // STORAGE 7
function setBlockProducer(producer) {
sstore(Storage_blockProducer, producer)
}
}
}
}
| ~ 1 weeks at 12 second block times
| uint256 constant public FINALIZATION_DELAY = 7 days / 12; | 12,672,628 | [
1,
98,
404,
17314,
622,
2593,
2205,
1203,
4124,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
2254,
5034,
5381,
1071,
17563,
1013,
25084,
67,
26101,
273,
2371,
4681,
342,
2593,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/80001/0x4436485155E81382b8DE76b29d4f79C52C27AAF7/sources/contracts/dao/ERC1155Dao.sol | * @notice allows token owner to list a token for auction. emits the AuctionState event. Requirements: ‼ contract should not be paused. ‼ token with `tokenId + serialNo` must not be already listed for auction or fixed price. ‼ token with `tokenId + serialNo` must not be already listed for lending. ‼ caller must be the owner of the the token `tokenId + serialNo`. ‼ `biddingLife` must be multiple of day and must atleast 3 days. ‼ auction cannot be held before all tokens from contract are sold. ‼ token with `tokenId` must not be expired. ‼ token with `tokenId + serialNo` life must be enough. Signature for listForAuction(string,uint256,uint48) : `0xd653daa3` @param tokenId id of the token being bought. @param serialNo serial Number of the token. @param biddingLife timestamp for number of days for which auction will run./ | function listForAuction(
string memory tokenId,
uint256 serialNo,
uint48 biddingLife
) external whenNotPaused {
TokenBearer memory tokenOwner = _tokenBearer[tokenId][serialNo];
if (tokenOwner.fixedOrAuction != 0) revert NotAvailableForOperation();
if (tokenOwner.lendingStatus) revert EndLending();
if (tokenOwner.user != msg.sender) revert TokenOwnerAllowed();
if (
biddingLife > 0 && biddingLife % 86400 == 0 && biddingLife >= 259200
) revert LifeMustBeMultipleofDay(3);
if (_balances[tokenId][address(this)] != 0)
revert NoTransferOrBidBeforeSale();
TokenDetails memory tokenDet = _tokenDetails[tokenId];
if (tokenOwner.startOfLife == 0 && block.timestamp > tokenDet.expireOn)
revert TokenExpired();
if (
tokenOwner.startOfLife != 0 &&
block.timestamp + biddingLife > tokenOwner.endOfLife
) revert NotEnoughTokenLife();
uint104 bidStartingPrice;
unchecked {
if (tokenOwner.startOfLife == 0) {
bidStartingPrice = (tokenDet.tokenPrice / 100) * 50;
bidStartingPrice =
((tokenDet.tokenPrice / 100) * 50) *
(((tokenOwner.endOfLife - tokenOwner.startOfLife) / 100) *
tokenOwner.endOfLife);
}
}
_tokenBearer[tokenId][serialNo] = TokenBearer({
user: tokenOwner.user,
startOfLife: tokenOwner.startOfLife,
endOfLife: tokenOwner.endOfLife,
borrower: address(0),
lendingStartTimestamp: 0,
borrowingStartTimestamp: 0,
bidStartingPrice: bidStartingPrice,
biddingLife: biddingLife,
listingPrice: 0,
lendingStatus: false,
lendingPeriod: 0,
borrowingPeriod: 0,
lendingPricePerDay: 0,
fixedOrAuction: 2,
isActivated: tokenOwner.isActivated
});
emit AuctionState(
tokenId,
serialNo,
biddingLife,
bidStartingPrice,
tokenOwner.user,
block.timestamp,
true
);
}
| 5,682,215 | [
1,
5965,
87,
1147,
3410,
358,
666,
279,
1147,
364,
279,
4062,
18,
24169,
326,
432,
4062,
1119,
871,
18,
29076,
30,
1377,
225,
163,
227,
125,
6835,
1410,
486,
506,
17781,
18,
1377,
225,
163,
227,
125,
1147,
598,
1375,
2316,
548,
397,
2734,
2279,
68,
1297,
486,
506,
1818,
12889,
364,
279,
4062,
578,
5499,
6205,
18,
1377,
225,
163,
227,
125,
1147,
598,
1375,
2316,
548,
397,
2734,
2279,
68,
1297,
486,
506,
1818,
12889,
364,
328,
2846,
18,
1377,
225,
163,
227,
125,
4894,
1297,
506,
326,
3410,
434,
326,
326,
1147,
1375,
2316,
548,
397,
2734,
2279,
8338,
1377,
225,
163,
227,
125,
1375,
70,
1873,
310,
15315,
68,
1297,
506,
3229,
434,
2548,
471,
1297,
20098,
890,
4681,
18,
1377,
225,
163,
227,
125,
279,
4062,
2780,
506,
15770,
1865,
777,
2430,
628,
6835,
854,
272,
1673,
18,
1377,
225,
163,
227,
125,
2
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
]
| [
1,
565,
445,
666,
1290,
37,
4062,
12,
203,
3639,
533,
3778,
1147,
548,
16,
203,
3639,
2254,
5034,
2734,
2279,
16,
203,
3639,
2254,
8875,
324,
1873,
310,
15315,
203,
565,
262,
3903,
1347,
1248,
28590,
288,
203,
3639,
3155,
19547,
3778,
1147,
5541,
273,
389,
2316,
19547,
63,
2316,
548,
6362,
8818,
2279,
15533,
203,
203,
3639,
309,
261,
2316,
5541,
18,
12429,
1162,
37,
4062,
480,
374,
13,
15226,
2288,
5268,
1290,
2988,
5621,
203,
3639,
309,
261,
2316,
5541,
18,
80,
2846,
1482,
13,
15226,
4403,
48,
2846,
5621,
203,
3639,
309,
261,
2316,
5541,
18,
1355,
480,
1234,
18,
15330,
13,
15226,
3155,
5541,
5042,
5621,
203,
3639,
309,
261,
203,
5411,
324,
1873,
310,
15315,
405,
374,
597,
324,
1873,
310,
15315,
738,
21451,
422,
374,
597,
324,
1873,
310,
15315,
1545,
576,
6162,
6976,
203,
3639,
262,
15226,
28128,
10136,
1919,
8438,
792,
4245,
12,
23,
1769,
203,
3639,
309,
261,
67,
70,
26488,
63,
2316,
548,
6362,
2867,
12,
2211,
25887,
480,
374,
13,
203,
5411,
15226,
2631,
5912,
1162,
17763,
4649,
30746,
5621,
203,
203,
3639,
3155,
3790,
3778,
1147,
4986,
273,
389,
2316,
3790,
63,
2316,
548,
15533,
203,
203,
3639,
309,
261,
2316,
5541,
18,
1937,
951,
15315,
422,
374,
597,
1203,
18,
5508,
405,
1147,
4986,
18,
14070,
1398,
13,
203,
5411,
15226,
3155,
10556,
5621,
203,
3639,
309,
261,
203,
5411,
1147,
5541,
18,
1937,
951,
15315,
480,
374,
597,
203,
5411,
1203,
18,
5508,
397,
324,
1873,
310,
15315,
405,
1147,
2
]
|
//Address: 0x3ca53621001e34786d63311691ace2203cab61e8
//Contract name: Distribution
//Balance: 0 Ether
//Verification Date: 3/27/2018
//Transacion Count: 43
// CODE STARTS HERE
pragma solidity ^0.4.18;
/*
Copyright 2017, Anton Egorov (Mothership Foundation)
Copyright 2017, An Hoang Phan Ngo (Mothership Foundation)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// File: contracts/interface/Controlled.sol
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
function Controlled() public { controller = msg.sender; }
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
// File: contracts/interface/Burnable.sol
/// @dev Burnable introduces a burner role, which could be used to destroy
/// tokens. The burner address could be changed by himself.
contract Burnable is Controlled {
address public burner;
/// @notice The function with this modifier could be called by a controller
/// as well as by a burner. But burner could use the onlt his/her address as
/// a target.
modifier onlyControllerOrBurner(address target) {
assert(msg.sender == controller || (msg.sender == burner && msg.sender == target));
_;
}
modifier onlyBurner {
assert(msg.sender == burner);
_;
}
/// Contract creator become a burner by default
function Burnable() public { burner = msg.sender;}
/// @notice Change a burner address
/// @param _newBurner The new burner address
function changeBurner(address _newBurner) public onlyBurner {
burner = _newBurner;
}
}
// File: contracts/interface/ERC20Token.sol
// @dev Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
contract ERC20Token {
/// total amount of tokens
function totalSupply() public view returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// File: contracts/interface/MiniMeTokenI.sol
/// @dev MiniMeToken interface. Using this interface instead of whole contracts
/// will reduce contract sise and gas cost
contract MiniMeTokenI is ERC20Token, Burnable {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
string public version = "MMT_0.1"; //An arbitrary versioning scheme
///////////////////
// ERC20 Methods
///////////////////
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData) public returns (bool success);
////////////////
// Query balance and totalSupply in History
////////////////
/// @dev Queries the balance of `_owner` at a specific `_blockNumber`
/// @param _owner The address from which the balance will be retrieved
/// @param _blockNumber The block number when the balance is queried
/// @return The balance at `_blockNumber`
function balanceOfAt(
address _owner,
uint _blockNumber) public constant returns (uint);
/// @notice Total amount of tokens at a specific `_blockNumber`.
/// @param _blockNumber The block number when the totalSupply is queried
/// @return The total amount of tokens at `_blockNumber`
function totalSupplyAt(uint _blockNumber) public constant returns(uint);
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function mintTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
/////////////////
// Finalize
////////////////
function finalize() public;
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public;
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
// File: contracts/interface/TokenController.sol
/// @dev The token controller contract must implement these functions
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyMintTokens(
address _owner,
uint _amount,
bytes32 _paidTxID) public returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
// File: contracts/Distribution.sol
contract Distribution is Controlled, TokenController {
/// Record tx details for each minting operation
struct Transaction {
uint256 amount;
bytes32 paidTxID;
}
MiniMeTokenI public token;
address public reserveWallet; // Team's wallet address
uint256 public totalSupplyCap; // Total Token supply to be generated
uint256 public totalReserve; // A number of tokens to reserve for the team/bonuses
uint256 public finalizedBlock;
/// Record all transaction details for all minting operations
mapping (address => Transaction[]) allTransactions;
/// @param _token Address of the SEN token contract
/// the contribution finalizes.
/// @param _reserveWallet Team's wallet address to distribute reserved pool
/// @param _totalSupplyCap Maximum amount of tokens to generate during the contribution
/// @param _totalReserve A number of tokens to reserve for the team/bonuses
function Distribution(
address _token,
address _reserveWallet,
uint256 _totalSupplyCap,
uint256 _totalReserve
) public onlyController
{
// Initialize only once
assert(address(token) == 0x0);
token = MiniMeTokenI(_token);
reserveWallet = _reserveWallet;
require(_totalReserve < _totalSupplyCap);
totalSupplyCap = _totalSupplyCap;
totalReserve = _totalReserve;
assert(token.totalSupply() == 0);
assert(token.decimals() == 18); // Same amount of decimals as ETH
}
function distributionCap() public constant returns (uint256) {
return totalSupplyCap - totalReserve;
}
/// @notice This method can be called the distribution cap is reached only
function finalize() public onlyController {
assert(token.totalSupply() >= distributionCap());
// Mint reserve pool
doMint(reserveWallet, totalReserve);
finalizedBlock = getBlockNumber();
token.finalize(); // Token becomes unmintable after this
// Distribution controller becomes a Token controller
token.changeController(controller);
Finalized();
}
//////////
// TokenController functions
//////////
function proxyMintTokens(
address _th,
uint256 _amount,
bytes32 _paidTxID
) public onlyController returns (bool)
{
require(_th != 0x0);
require(_amount + token.totalSupply() <= distributionCap());
doMint(_th, _amount);
addTransaction(
allTransactions[_th],
_amount,
_paidTxID);
Purchase(
_th,
_amount,
_paidTxID);
return true;
}
function onTransfer(address, address, uint256) public returns (bool) {
return false;
}
function onApprove(address, address, uint256) public returns (bool) {
return false;
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public onlyController {
if (token.controller() == address(this)) {
token.claimTokens(_token);
}
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
ERC20Token otherToken = ERC20Token(_token);
uint256 balance = otherToken.balanceOf(this);
otherToken.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
//////////////////////////////////
// Minting tokens and oraclization
//////////////////////////////////
/// Total transaction count belong to an address
function totalTransactionCount(address _owner) public constant returns(uint) {
return allTransactions[_owner].length;
}
/// Query a transaction details by address and its index in transactions array
function getTransactionAtIndex(address _owner, uint index) public constant returns(
uint256 _amount,
bytes32 _paidTxID
) {
_amount = allTransactions[_owner][index].amount;
_paidTxID = allTransactions[_owner][index].paidTxID;
}
/// Save transaction details belong to an address
/// @param transactions all transactions belong to an address
/// @param _amount amount of tokens issued in the transaction
/// @param _paidTxID blockchain tx_hash
function addTransaction(
Transaction[] storage transactions,
uint _amount,
bytes32 _paidTxID
) internal
{
Transaction storage newTx = transactions[transactions.length++];
newTx.amount = _amount;
newTx.paidTxID = _paidTxID;
}
function doMint(address _th, uint256 _amount) internal {
assert(token.mintTokens(_th, _amount));
}
//////////
// Testing specific methods
//////////
/// @notice This function is overridden by the test Mocks.
function getBlockNumber() internal constant returns (uint256) { return block.number; }
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount);
event Purchase(
address indexed _owner,
uint256 _amount,
bytes32 _paidTxID
);
event Finalized();
}
| A number of tokens to reserve for the team/bonuses
| uint256 public totalReserve; | 6,404,902 | [
1,
37,
1300,
434,
2430,
358,
20501,
364,
326,
5927,
19,
18688,
6117,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
2254,
5034,
1071,
2078,
607,
6527,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity 0.5.14;
contract Constant {
enum ActionType { DepositAction, WithdrawAction, BorrowAction, RepayAction }
address public constant ETH_ADDR = 0x000000000000000000000000000000000000000E;
uint256 public constant INT_UNIT = 10 ** uint256(18);
uint256 public constant ACCURACY = 10 ** 18;
// Polygon mainnet blocks per year
uint256 public constant BLOCKS_PER_YEAR = 2102400;
}
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// This is for per user
library AccountTokenLib {
using SafeMath for uint256;
struct TokenInfo {
// Deposit info
uint256 depositPrincipal; // total deposit principal of ther user
uint256 depositInterest; // total deposit interest of the user
uint256 lastDepositBlock; // the block number of user's last deposit
// Borrow info
uint256 borrowPrincipal; // total borrow principal of ther user
uint256 borrowInterest; // total borrow interest of ther user
uint256 lastBorrowBlock; // the block number of user's last borrow
}
uint256 constant BASE = 10**18;
// returns the principal
function getDepositPrincipal(TokenInfo storage self) public view returns(uint256) {
return self.depositPrincipal;
}
function getBorrowPrincipal(TokenInfo storage self) public view returns(uint256) {
return self.borrowPrincipal;
}
function getDepositBalance(TokenInfo storage self, uint accruedRate) public view returns(uint256) {
return self.depositPrincipal.add(calculateDepositInterest(self, accruedRate));
}
function getBorrowBalance(TokenInfo storage self, uint accruedRate) public view returns(uint256) {
return self.borrowPrincipal.add(calculateBorrowInterest(self, accruedRate));
}
function getLastDepositBlock(TokenInfo storage self) public view returns(uint256) {
return self.lastDepositBlock;
}
function getLastBorrowBlock(TokenInfo storage self) public view returns(uint256) {
return self.lastBorrowBlock;
}
function getDepositInterest(TokenInfo storage self) public view returns(uint256) {
return self.depositInterest;
}
function getBorrowInterest(TokenInfo storage self) public view returns(uint256) {
return self.borrowInterest;
}
function borrow(TokenInfo storage self, uint256 amount, uint256 accruedRate, uint256 _block) public {
newBorrowCheckpoint(self, accruedRate, _block);
self.borrowPrincipal = self.borrowPrincipal.add(amount);
}
/**
* Update token info for withdraw. The interest will be withdrawn with higher priority.
*/
function withdraw(TokenInfo storage self, uint256 amount, uint256 accruedRate, uint256 _block) public {
newDepositCheckpoint(self, accruedRate, _block);
if (self.depositInterest >= amount) {
self.depositInterest = self.depositInterest.sub(amount);
} else if (self.depositPrincipal.add(self.depositInterest) >= amount) {
self.depositPrincipal = self.depositPrincipal.sub(amount.sub(self.depositInterest));
self.depositInterest = 0;
} else {
self.depositPrincipal = 0;
self.depositInterest = 0;
}
}
/**
* Update token info for deposit
*/
function deposit(TokenInfo storage self, uint256 amount, uint accruedRate, uint256 _block) public {
newDepositCheckpoint(self, accruedRate, _block);
self.depositPrincipal = self.depositPrincipal.add(amount);
}
function repay(TokenInfo storage self, uint256 amount, uint accruedRate, uint256 _block) public {
// updated rate (new index rate), applying the rate from startBlock(checkpoint) to currBlock
newBorrowCheckpoint(self, accruedRate, _block);
// user owes money, then he tries to repays
if (self.borrowInterest > amount) {
self.borrowInterest = self.borrowInterest.sub(amount);
} else if (self.borrowPrincipal.add(self.borrowInterest) > amount) {
self.borrowPrincipal = self.borrowPrincipal.sub(amount.sub(self.borrowInterest));
self.borrowInterest = 0;
} else {
self.borrowPrincipal = 0;
self.borrowInterest = 0;
}
}
function newDepositCheckpoint(TokenInfo storage self, uint accruedRate, uint256 _block) public {
self.depositInterest = calculateDepositInterest(self, accruedRate);
self.lastDepositBlock = _block;
}
function newBorrowCheckpoint(TokenInfo storage self, uint accruedRate, uint256 _block) public {
self.borrowInterest = calculateBorrowInterest(self, accruedRate);
self.lastBorrowBlock = _block;
}
// Calculating interest according to the new rate
// calculated starting from last deposit checkpoint
function calculateDepositInterest(TokenInfo storage self, uint accruedRate) public view returns(uint256) {
return self.depositPrincipal.add(self.depositInterest).mul(accruedRate).sub(self.depositPrincipal.mul(BASE)).div(BASE);
}
function calculateBorrowInterest(TokenInfo storage self, uint accruedRate) public view returns(uint256) {
uint256 _balance = self.borrowPrincipal;
if(accruedRate == 0 || _balance == 0 || BASE >= accruedRate) {
return self.borrowInterest;
} else {
return _balance.add(self.borrowInterest).mul(accruedRate).sub(_balance.mul(BASE)).div(BASE);
}
}
}
/**
* @notice Bitmap library to set or unset bits on bitmap value
*/
library BitmapLib {
/**
* @dev Sets the given bit in the bitmap value
* @param _bitmap Bitmap value to update the bit in
* @param _index Index range from 0 to 127
* @return Returns the updated bitmap value
*/
function setBit(uint128 _bitmap, uint8 _index) internal pure returns (uint128) {
// Suppose `_bitmap` is in bit value:
// 0001 0100 = represents third(_index == 2) and fifth(_index == 4) bit is set
// Bit not set, hence, set the bit
if( ! isBitSet(_bitmap, _index)) {
// Suppose `_index` is = 3 = 4th bit
// mask = 0000 1000 = Left shift to create mask to find 4rd bit status
uint128 mask = uint128(1) << _index;
// Setting the corrospending bit in _bitmap
// Performing OR (|) operation
// 0001 0100 (_bitmap)
// 0000 1000 (mask)
// -------------------
// 0001 1100 (result)
return _bitmap | mask;
}
// Bit already set, just return without any change
return _bitmap;
}
/**
* @dev Unsets the bit in given bitmap
* @param _bitmap Bitmap value to update the bit in
* @param _index Index range from 0 to 127
* @return Returns the updated bitmap value
*/
function unsetBit(uint128 _bitmap, uint8 _index) internal pure returns (uint128) {
// Suppose `_bitmap` is in bit value:
// 0001 0100 = represents third(_index == 2) and fifth(_index == 4) bit is set
// Bit is set, hence, unset the bit
if(isBitSet(_bitmap, _index)) {
// Suppose `_index` is = 2 = 3th bit
// mask = 0000 0100 = Left shift to create mask to find 3rd bit status
uint128 mask = uint128(1) << _index;
// Performing Bitwise NOT(~) operation
// 1111 1011 (mask)
mask = ~mask;
// Unsetting the corrospending bit in _bitmap
// Performing AND (&) operation
// 0001 0100 (_bitmap)
// 1111 1011 (mask)
// -------------------
// 0001 0000 (result)
return _bitmap & mask;
}
// Bit not set, just return without any change
return _bitmap;
}
/**
* @dev Returns true if the corrosponding bit set in the bitmap
* @param _bitmap Bitmap value to check
* @param _index Index to check. Index range from 0 to 127
* @return Returns true if bit is set, false otherwise
*/
function isBitSet(uint128 _bitmap, uint8 _index) internal pure returns (bool) {
require(_index < 128, "Index out of range for bit operation");
// Suppose `_bitmap` is in bit value:
// 0001 0100 = represents third(_index == 2) and fifth(_index == 4) bit is set
// Suppose `_index` is = 2 = 3th bit
// 0000 0100 = Left shift to create mask to find 3rd bit status
uint128 mask = uint128(1) << _index;
// Example: When bit is set:
// Performing AND (&) operation
// 0001 0100 (_bitmap)
// 0000 0100 (mask)
// -------------------------
// 0000 0100 (bitSet > 0)
// Example: When bit is not set:
// Performing AND (&) operation
// 0001 0100 (_bitmap)
// 0000 1000 (mask)
// -------------------------
// 0000 0000 (bitSet == 0)
uint128 bitSet = _bitmap & mask;
// Bit is set when greater than zero, else not set
return bitSet > 0;
}
}
interface AggregatorInterface {
function latestAnswer() external view returns (int256);
function latestTimestamp() external view returns (uint256);
function latestRound() external view returns (uint256);
function getAnswer(uint256 roundId) external view returns (int256);
function getTimestamp(uint256 roundId) external view returns (uint256);
event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 timestamp);
event NewRound(uint256 indexed roundId, address indexed startedBy);
}
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Utils{
function _isETH(address globalConfig, address _token) public view returns (bool) {
return GlobalConfig(globalConfig).constants().ETH_ADDR() == _token;
}
function getDivisor(address globalConfig, address _token) public view returns (uint256) {
if(_isETH(globalConfig, _token)) return GlobalConfig(globalConfig).constants().INT_UNIT();
return 10 ** uint256(GlobalConfig(globalConfig).tokenInfoRegistry().getTokenDecimals(_token));
}
}
library SavingLib {
using SafeERC20 for IERC20;
/**
* Receive the amount of token from msg.sender
* @param _amount amount of token
* @param _token token address
*/
function receive(GlobalConfig globalConfig, uint256 _amount, address _token) public {
if (Utils._isETH(address(globalConfig), _token)) {
require(msg.value == _amount, "The amount is not sent from address.");
} else {
//When only tokens received, msg.value must be 0
require(msg.value == 0, "msg.value must be 0 when receiving tokens");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
}
}
/**
* Send the amount of token to an address
* @param _amount amount of token
* @param _token token address
*/
function send(GlobalConfig globalConfig, uint256 _amount, address _token) public {
if (Utils._isETH(address(globalConfig), _token)) {
msg.sender.transfer(_amount);
} else {
IERC20(_token).safeTransfer(msg.sender, _amount);
}
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Converts an `address` into `address payable`. Note that this is
* simply a type cast: the actual underlying value is not changed.
*
* _Available since v2.4.0._
*/
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*
* _Available since v2.4.0._
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success, ) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
/**
* @dev Token Info Registry to manage Token information
* The Owner of the contract allowed to update the information
*/
contract TokenRegistry is Ownable, Constant {
using SafeMath for uint256;
/**
* @dev TokenInfo struct stores Token Information, this includes:
* ERC20 Token address, Compound Token address, ChainLink Aggregator address etc.
* @notice This struct will consume 5 storage locations
*/
struct TokenInfo {
// Token index, can store upto 255
uint8 index;
// ERC20 Token decimal
uint8 decimals;
// If token is enabled / disabled
bool enabled;
// Is ERC20 token charge transfer fee?
bool isTransferFeeEnabled;
// Is Token supported on Compound
bool isSupportedOnCompound;
// cToken address on Compound
address cToken;
// Chain Link Aggregator address for TOKEN/ETH pair
address chainLinkOracle;
// Borrow LTV, by default 60%
uint256 borrowLTV;
}
event TokenAdded(address indexed token);
event TokenUpdated(address indexed token);
uint256 public constant MAX_TOKENS = 128;
uint256 public constant SCALE = 100;
// TokenAddress to TokenInfo mapping
mapping (address => TokenInfo) public tokenInfo;
// TokenAddress array
address[] public tokens;
GlobalConfig public globalConfig;
/**
*/
modifier whenTokenExists(address _token) {
require(isTokenExist(_token), "Token not exists");
_;
}
/**
* initializes the symbols structure
*/
function initialize(GlobalConfig _globalConfig) public onlyOwner{
globalConfig = _globalConfig;
}
/**
* @dev Add a new token to registry
* @param _token ERC20 Token address
* @param _decimals Token's decimals
* @param _isTransferFeeEnabled Is token changes transfer fee
* @param _isSupportedOnCompound Is token supported on Compound
* @param _cToken cToken contract address
* @param _chainLinkOracle Chain Link Aggregator address to get TOKEN/ETH rate
*/
function addToken(
address _token,
uint8 _decimals,
bool _isTransferFeeEnabled,
bool _isSupportedOnCompound,
address _cToken,
address _chainLinkOracle
)
public
onlyOwner
{
require(_token != address(0), "Token address is zero");
require(!isTokenExist(_token), "Token already exist");
require(_chainLinkOracle != address(0), "ChainLinkAggregator address is zero");
require(tokens.length < MAX_TOKENS, "Max token limit reached");
TokenInfo storage storageTokenInfo = tokenInfo[_token];
storageTokenInfo.index = uint8(tokens.length);
storageTokenInfo.decimals = _decimals;
storageTokenInfo.enabled = true;
storageTokenInfo.isTransferFeeEnabled = _isTransferFeeEnabled;
storageTokenInfo.isSupportedOnCompound = _isSupportedOnCompound;
storageTokenInfo.cToken = _cToken;
storageTokenInfo.chainLinkOracle = _chainLinkOracle;
// Default values
storageTokenInfo.borrowLTV = 60; //6e7; // 60%
tokens.push(_token);
emit TokenAdded(_token);
}
function updateBorrowLTV(
address _token,
uint256 _borrowLTV
)
external
onlyOwner
whenTokenExists(_token)
{
if (tokenInfo[_token].borrowLTV == _borrowLTV)
return;
// require(_borrowLTV != 0, "Borrow LTV is zero");
require(_borrowLTV < SCALE, "Borrow LTV must be less than Scale");
// require(liquidationThreshold > _borrowLTV, "Liquidation threshold must be greater than Borrow LTV");
tokenInfo[_token].borrowLTV = _borrowLTV;
emit TokenUpdated(_token);
}
/**
*/
function updateTokenTransferFeeFlag(
address _token,
bool _isTransfeFeeEnabled
)
external
onlyOwner
whenTokenExists(_token)
{
if (tokenInfo[_token].isTransferFeeEnabled == _isTransfeFeeEnabled)
return;
tokenInfo[_token].isTransferFeeEnabled = _isTransfeFeeEnabled;
emit TokenUpdated(_token);
}
/**
*/
function updateTokenSupportedOnCompoundFlag(
address _token,
bool _isSupportedOnCompound
)
external
onlyOwner
whenTokenExists(_token)
{
if (tokenInfo[_token].isSupportedOnCompound == _isSupportedOnCompound)
return;
tokenInfo[_token].isSupportedOnCompound = _isSupportedOnCompound;
emit TokenUpdated(_token);
}
/**
*/
function updateCToken(
address _token,
address _cToken
)
external
onlyOwner
whenTokenExists(_token)
{
if (tokenInfo[_token].cToken == _cToken)
return;
tokenInfo[_token].cToken = _cToken;
emit TokenUpdated(_token);
}
/**
*/
function updateChainLinkAggregator(
address _token,
address _chainLinkOracle
)
external
onlyOwner
whenTokenExists(_token)
{
if (tokenInfo[_token].chainLinkOracle == _chainLinkOracle)
return;
tokenInfo[_token].chainLinkOracle = _chainLinkOracle;
emit TokenUpdated(_token);
}
function enableToken(address _token) external onlyOwner whenTokenExists(_token) {
require(!tokenInfo[_token].enabled, "Token already enabled");
tokenInfo[_token].enabled = true;
emit TokenUpdated(_token);
}
function disableToken(address _token) external onlyOwner whenTokenExists(_token) {
require(tokenInfo[_token].enabled, "Token already disabled");
tokenInfo[_token].enabled = false;
emit TokenUpdated(_token);
}
// =====================
// GETTERS
// =====================
/**
* @dev Is token address is registered
* @param _token token address
* @return Returns `true` when token registered, otherwise `false`
*/
function isTokenExist(address _token) public view returns (bool isExist) {
isExist = tokenInfo[_token].chainLinkOracle != address(0);
}
function getTokens() external view returns (address[] memory) {
return tokens;
}
function getTokenIndex(address _token) external view returns (uint8) {
return tokenInfo[_token].index;
}
function isTokenEnabled(address _token) external view returns (bool) {
return tokenInfo[_token].enabled;
}
/**
*/
function getCTokens() external view returns (address[] memory cTokens) {
uint256 len = tokens.length;
cTokens = new address[](len);
for(uint256 i = 0; i < len; i++) {
cTokens[i] = tokenInfo[tokens[i]].cToken;
}
}
function getTokenDecimals(address _token) public view returns (uint8) {
return tokenInfo[_token].decimals;
}
function isTransferFeeEnabled(address _token) external view returns (bool) {
return tokenInfo[_token].isTransferFeeEnabled;
}
function isSupportedOnCompound(address _token) external view returns (bool) {
return tokenInfo[_token].isSupportedOnCompound;
}
/**
*/
function getCToken(address _token) external view returns (address) {
return tokenInfo[_token].cToken;
}
function getChainLinkAggregator(address _token) external view returns (address) {
return tokenInfo[_token].chainLinkOracle;
}
function getBorrowLTV(address _token) external view returns (uint256) {
return tokenInfo[_token].borrowLTV;
}
function getCoinLength() public view returns (uint256 length) {
return tokens.length;
}
function addressFromIndex(uint index) public view returns(address) {
require(index < tokens.length, "coinIndex must be smaller than the coins length.");
return tokens[index];
}
function priceFromIndex(uint index) public view returns(uint256) {
require(index < tokens.length, "coinIndex must be smaller than the coins length.");
address tokenAddress = tokens[index];
// Temp fix
if(Utils._isETH(address(globalConfig), tokenAddress)) {
return 1e18;
}
return uint256(AggregatorInterface(tokenInfo[tokenAddress].chainLinkOracle).latestAnswer());
}
function priceFromAddress(address tokenAddress) public view returns(uint256) {
if(Utils._isETH(address(globalConfig), tokenAddress)) {
return 1e18;
}
return uint256(AggregatorInterface(tokenInfo[tokenAddress].chainLinkOracle).latestAnswer());
}
function _priceFromAddress(address _token) internal view returns (uint) {
return
_token != ETH_ADDR
? uint256(AggregatorInterface(tokenInfo[_token].chainLinkOracle).latestAnswer())
: INT_UNIT;
}
function _tokenDivisor(address _token) internal view returns (uint) {
return _token != ETH_ADDR ? 10**uint256(tokenInfo[_token].decimals) : INT_UNIT;
}
function getTokenInfoFromIndex(uint index)
external
view
whenTokenExists(addressFromIndex(index))
returns (
address,
uint256,
uint256,
uint256
)
{
address token = tokens[index];
return (
token,
_tokenDivisor(token),
_priceFromAddress(token),
tokenInfo[token].borrowLTV
);
}
function getTokenInfoFromAddress(address _token)
external
view
whenTokenExists(_token)
returns (
uint8,
uint256,
uint256,
uint256
)
{
return (
tokenInfo[_token].index,
_tokenDivisor(_token),
_priceFromAddress(_token),
tokenInfo[_token].borrowLTV
);
}
// function _isETH(address _token) public view returns (bool) {
// return globalConfig.constants().ETH_ADDR() == _token;
// }
// function getDivisor(address _token) public view returns (uint256) {
// if(_isETH(_token)) return INT_UNIT;
// return 10 ** uint256(getTokenDecimals(_token));
// }
mapping(address => uint) public depositeMiningSpeeds;
mapping(address => uint) public borrowMiningSpeeds;
function updateMiningSpeed(address _token, uint _depositeMiningSpeed, uint _borrowMiningSpeed) public onlyOwner{
if(_depositeMiningSpeed != depositeMiningSpeeds[_token]) {
depositeMiningSpeeds[_token] = _depositeMiningSpeed;
}
if(_borrowMiningSpeed != borrowMiningSpeeds[_token]) {
borrowMiningSpeeds[_token] = _borrowMiningSpeed;
}
emit TokenUpdated(_token);
}
}
/**
* @title Initializable
*
* @dev Helper contract to support initializer functions. To use it, replace
* the constructor with a function that has the `initializer` modifier.
* WARNING: Unlike constructors, initializer functions must be manually
* invoked. This applies both to deploying an Initializable contract, as well
* as extending an Initializable contract via inheritance.
* WARNING: When used with inheritance, manual care must be taken to not invoke
* a parent initializer twice, or ensure that all initializers are idempotent,
* because this is not dealt with automatically as with constructors.
*/
contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private initializing;
/**
* @dev Modifier to use in the initializer function of a contract.
*/
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
contract InitializablePausable {
/**
* @dev Emitted when the pause is triggered by a pauser (`account`).
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by a pauser (`account`).
*/
event Unpaused(address account);
address private globalConfig;
bool private _paused;
function _initialize(address _globalConfig) internal {
globalConfig = _globalConfig;
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
/**
* @dev Called by a pauser to pause, triggers stopped state.
*/
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(GlobalConfig(globalConfig).owner());
}
/**
* @dev Called by a pauser to unpause, returns to normal state.
*/
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(GlobalConfig(globalConfig).owner());
}
modifier onlyPauser() {
require(msg.sender == GlobalConfig(globalConfig).owner(), "PauserRole: caller does not have the Pauser role");
_;
}
}
/**
* @notice Code copied from OpenZeppelin, to make it an upgradable contract
*/
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*
* _Since v2.5.0:_ this module is now much more gas efficient, given net gas
* metering changes introduced in the Istanbul hardfork.
*/
contract InitializableReentrancyGuard {
bool private _notEntered;
function _initialize() internal {
// Storing an initial non-zero value makes deployment a bit more
// expensive, but in exchange the refund on every call to nonReentrant
// will be lower in amount. Since refunds are capped to a percetange of
// the total transaction's gas, it is best to keep them low in cases
// like this one, to increase the likelihood of the full refund coming
// into effect.
_notEntered = true;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_notEntered, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_notEntered = false;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_notEntered = true;
}
}
contract SavingAccount is Initializable, InitializableReentrancyGuard, Constant, InitializablePausable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
GlobalConfig public globalConfig;
address public constant FIN_ADDR = 0x576c990A8a3E7217122e9973b2230A3be9678E94;
address public constant COMP_ADDR = address(0);
event Transfer(address indexed token, address from, address to, uint256 amount);
event Borrow(address indexed token, address from, uint256 amount);
event Repay(address indexed token, address from, uint256 amount);
event Deposit(address indexed token, address from, uint256 amount);
event Withdraw(address indexed token, address from, uint256 amount);
event WithdrawAll(address indexed token, address from, uint256 amount);
event Liquidate(address liquidator, address borrower, address borrowedToken, uint256 repayAmount, address collateralToken, uint256 payAmount);
event Claim(address from, uint256 amount);
event WithdrawCOMP(address beneficiary, uint256 amount);
modifier onlySupportedToken(address _token) {
if(_token != ETH_ADDR) {
require(globalConfig.tokenInfoRegistry().isTokenExist(_token), "Unsupported token");
}
_;
}
modifier onlyEnabledToken(address _token) {
require(globalConfig.tokenInfoRegistry().isTokenEnabled(_token), "The token is not enabled");
_;
}
modifier onlyAuthorized() {
require(msg.sender == address(globalConfig.bank()),
"Only authorized to call from DeFiner internal contracts.");
_;
}
modifier onlyOwner() {
require(msg.sender == GlobalConfig(globalConfig).owner(), "Only owner");
_;
}
/**
* Initialize function to be called by the Deployer for the first time
* @param _tokenAddresses list of token addresses
* @param _cTokenAddresses list of corresponding cToken addresses
* @param _globalConfig global configuration contract
*/
function initialize(
address[] memory _tokenAddresses,
address[] memory _cTokenAddresses,
GlobalConfig _globalConfig
)
public
initializer
{
// Initialize InitializableReentrancyGuard
super._initialize();
super._initialize(address(_globalConfig));
globalConfig = _globalConfig;
require(_tokenAddresses.length == _cTokenAddresses.length, "Token and cToken length don't match.");
uint tokenNum = _tokenAddresses.length;
for(uint i = 0;i < tokenNum;i++) {
if(_cTokenAddresses[i] != address(0x0) && _tokenAddresses[i] != ETH_ADDR) {
approveAll(_tokenAddresses[i]);
}
}
}
/**
* Approve transfer of all available tokens
* @param _token token address
*/
function approveAll(address _token) public {
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
require(cToken != address(0x0), "cToken address is zero");
IERC20(_token).safeApprove(cToken, 0);
IERC20(_token).safeApprove(cToken, uint256(-1));
}
/**
* Get current block number
* @return the current block number
*/
function getBlockNumber() internal view returns (uint) {
return block.number;
}
/**
* Transfer the token between users inside DeFiner
* @param _to the address that the token be transfered to
* @param _token token address
* @param _amount amout of tokens transfer
*/
function transfer(address _to, address _token, uint _amount) external onlySupportedToken(_token) onlyEnabledToken(_token) whenNotPaused nonReentrant {
globalConfig.bank().newRateIndexCheckpoint(_token);
uint256 amount = globalConfig.accounts().withdraw(msg.sender, _token, _amount);
globalConfig.accounts().deposit(_to, _token, amount);
emit Transfer(_token, msg.sender, _to, amount);
}
/**
* Borrow the amount of token from the saving pool.
* @param _token token address
* @param _amount amout of tokens to borrow
*/
function borrow(address _token, uint256 _amount) external onlySupportedToken(_token) onlyEnabledToken(_token) whenNotPaused nonReentrant {
require(_amount != 0, "Borrow zero amount of token is not allowed.");
globalConfig.bank().borrow(msg.sender, _token, _amount);
// Transfer the token on Ethereum
SavingLib.send(globalConfig, _amount, _token);
emit Borrow(_token, msg.sender, _amount);
}
/**
* Repay the amount of token back to the saving pool.
* @param _token token address
* @param _amount amout of tokens to borrow
* @dev If the repay amount is larger than the borrowed balance, the extra will be returned.
*/
function repay(address _token, uint256 _amount) public payable onlySupportedToken(_token) nonReentrant {
require(_amount != 0, "Amount is zero");
SavingLib.receive(globalConfig, _amount, _token);
// Add a new checkpoint on the index curve.
uint256 amount = globalConfig.bank().repay(msg.sender, _token, _amount);
// Send the remain money back
if(amount < _amount) {
SavingLib.send(globalConfig, _amount.sub(amount), _token);
}
emit Repay(_token, msg.sender, amount);
}
/**
* Deposit the amount of token to the saving pool.
* @param _token the address of the deposited token
* @param _amount the mount of the deposited token
*/
function deposit(address _token, uint256 _amount) public payable onlySupportedToken(_token) onlyEnabledToken(_token) nonReentrant {
require(_amount != 0, "Amount is zero");
SavingLib.receive(globalConfig, _amount, _token);
globalConfig.bank().deposit(msg.sender, _token, _amount);
emit Deposit(_token, msg.sender, _amount);
}
/**
* Withdraw a token from an address
* @param _token token address
* @param _amount amount to be withdrawn
*/
function withdraw(address _token, uint256 _amount) external onlySupportedToken(_token) whenNotPaused nonReentrant {
require(_amount != 0, "Amount is zero");
uint256 amount = globalConfig.bank().withdraw(msg.sender, _token, _amount);
SavingLib.send(globalConfig, amount, _token);
emit Withdraw(_token, msg.sender, amount);
}
/**
* Withdraw all tokens from the saving pool.
* @param _token the address of the withdrawn token
*/
function withdrawAll(address _token) external onlySupportedToken(_token) whenNotPaused nonReentrant {
// Sanity check
require(globalConfig.accounts().getDepositPrincipal(msg.sender, _token) > 0, "Token depositPrincipal must be greater than 0");
// Add a new checkpoint on the index curve.
globalConfig.bank().newRateIndexCheckpoint(_token);
// Get the total amount of token for the account
uint amount = globalConfig.accounts().getDepositBalanceCurrent(_token, msg.sender);
uint256 actualAmount = globalConfig.bank().withdraw(msg.sender, _token, amount);
if(actualAmount != 0) {
SavingLib.send(globalConfig, actualAmount, _token);
}
emit WithdrawAll(_token, msg.sender, actualAmount);
}
function liquidate(address _borrower, address _borrowedToken, address _collateralToken) public onlySupportedToken(_borrowedToken) onlySupportedToken(_collateralToken) whenNotPaused nonReentrant {
(uint256 repayAmount, uint256 payAmount) = globalConfig.accounts().liquidate(msg.sender, _borrower, _borrowedToken, _collateralToken);
emit Liquidate(msg.sender, _borrower, _borrowedToken, repayAmount, _collateralToken, payAmount);
}
/**
* Withdraw token from Compound
* @param _token token address
* @param _amount amount of token
*/
function fromCompound(address _token, uint _amount) external onlyAuthorized {
require(ICToken(globalConfig.tokenInfoRegistry().getCToken(_token)).redeemUnderlying(_amount) == 0, "redeemUnderlying failed");
}
function toCompound(address _token, uint _amount) external onlyAuthorized {
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
if (Utils._isETH(address(globalConfig), _token)) {
ICETH(cToken).mint.value(_amount)();
} else {
// uint256 success = ICToken(cToken).mint(_amount);
require(ICToken(cToken).mint(_amount) == 0, "mint failed");
}
}
function() external payable{}
/**
* An account claim all mined FIN token
*/
function claim() public nonReentrant returns (uint256) {
uint256 finAmount = globalConfig.accounts().claim(msg.sender);
IERC20(FIN_ADDR).safeTransfer(msg.sender, finAmount);
emit Claim(msg.sender, finAmount);
return finAmount;
}
function claimForToken(address _token) public nonReentrant returns (uint256) {
uint256 finAmount = globalConfig.accounts().claimForToken(msg.sender, _token);
if(finAmount > 0) IERC20(FIN_ADDR).safeTransfer(msg.sender, finAmount);
emit Claim(msg.sender, finAmount);
return finAmount;
}
/**
* Withdraw COMP token to beneficiary
*/
/*
function withdrawCOMP(address _beneficiary) external onlyOwner {
uint256 compBalance = IERC20(COMP_ADDR).balanceOf(address(this));
IERC20(COMP_ADDR).safeTransfer(_beneficiary, compBalance);
emit WithdrawCOMP(_beneficiary, compBalance);
}
*/
function version() public pure returns(string memory) {
return "v1.2.0";
}
}
interface IGlobalConfig {
function savingAccount() external view returns (address);
function tokenInfoRegistry() external view returns (TokenRegistry);
function bank() external view returns (Bank);
function deFinerCommunityFund() external view returns (address);
function deFinerRate() external view returns (uint256);
function liquidationThreshold() external view returns (uint256);
function liquidationDiscountRatio() external view returns (uint256);
}
contract Accounts is Constant, Initializable{
using AccountTokenLib for AccountTokenLib.TokenInfo;
using BitmapLib for uint128;
using SafeMath for uint256;
using Math for uint256;
mapping(address => Account) public accounts;
IGlobalConfig globalConfig;
mapping(address => uint256) public FINAmount;
modifier onlyAuthorized() {
_isAuthorized();
_;
}
struct Account {
// Note, it's best practice to use functions minusAmount, addAmount, totalAmount
// to operate tokenInfos instead of changing it directly.
mapping(address => AccountTokenLib.TokenInfo) tokenInfos;
uint128 depositBitmap;
uint128 borrowBitmap;
uint128 collateralBitmap;
bool isCollInit;
}
event CollateralFlagChanged(address indexed _account, uint8 _index, bool _enabled);
function _isAuthorized() internal view {
require(
msg.sender == address(globalConfig.savingAccount()) || msg.sender == address(globalConfig.bank()),
"not authorized"
);
}
/**
* Initialize the Accounts
* @param _globalConfig the global configuration contract
*/
function initialize(
IGlobalConfig _globalConfig
) public initializer {
globalConfig = _globalConfig;
}
/**
* @dev Initialize the Collateral flag Bitmap for given account
* @notice This function is required for the contract upgrade, as previous users didn't
* have this collateral feature. So need to init the collateralBitmap for each user.
* @param _account User account address
*/
function initCollateralFlag(address _account) public {
Account storage account = accounts[_account];
// For all users by default `isCollInit` will be `false`
if(account.isCollInit == false) {
// Two conditions:
// 1) An account has some position previous to this upgrade
// THEN: copy `depositBitmap` to `collateralBitmap`
// 2) A new account is setup after this upgrade
// THEN: `depositBitmap` will be zero for that user, so don't copy
// all deposited tokens be treated as collateral
if(account.depositBitmap > 0) account.collateralBitmap = account.depositBitmap;
account.isCollInit = true;
}
// when isCollInit == true, function will just return after if condition check
}
/**
* @dev Enable/Disable collateral for a given token
* @param _tokenIndex Index of the token
* @param _enable `true` to enable the collateral, `false` to disable
*/
function setCollateral(uint8 _tokenIndex, bool _enable) public {
address accountAddr = msg.sender;
initCollateralFlag(accountAddr);
Account storage account = accounts[accountAddr];
if(_enable) {
account.collateralBitmap = account.collateralBitmap.setBit(_tokenIndex);
// when set new collateral, no need to evaluate borrow power
} else {
account.collateralBitmap = account.collateralBitmap.unsetBit(_tokenIndex);
// when unset collateral, evaluate borrow power, only when user borrowed already
if(account.borrowBitmap > 0) {
require(getBorrowETH(accountAddr) <= getBorrowPower(accountAddr), "Insufficient collateral");
}
}
emit CollateralFlagChanged(msg.sender, _tokenIndex, _enable);
}
function setCollateral(uint8[] calldata _tokenIndexArr, bool[] calldata _enableArr) external {
require(_tokenIndexArr.length == _enableArr.length, "array length does not match");
for(uint i = 0; i < _tokenIndexArr.length; i++) {
setCollateral(_tokenIndexArr[i], _enableArr[i]);
}
}
function getCollateralStatus(address _account)
external
view
returns (address[] memory tokens, bool[] memory status)
{
Account memory account = accounts[_account];
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
tokens = tokenRegistry.getTokens();
uint256 tokensCount = tokens.length;
status = new bool[](tokensCount);
uint128 collBitmap = account.collateralBitmap;
for(uint i = 0; i < tokensCount; i++) {
// Example: 0001 << 1 => 0010 (mask for 2nd position)
uint128 mask = uint128(1) << uint128(i);
bool isEnabled = (collBitmap & mask) > 0;
if(isEnabled) status[i] = true;
}
}
/**
* Check if the user has deposit for any tokens
* @param _account address of the user
* @return true if the user has positive deposit balance
*/
function isUserHasAnyDeposits(address _account) public view returns (bool) {
Account storage account = accounts[_account];
return account.depositBitmap > 0;
}
/**
* Check if the user has deposit for a token
* @param _account address of the user
* @param _index index of the token
* @return true if the user has positive deposit balance for the token
*/
function isUserHasDeposits(address _account, uint8 _index) public view returns (bool) {
Account storage account = accounts[_account];
return account.depositBitmap.isBitSet(_index);
}
/**
* Check if the user has borrowed a token
* @param _account address of the user
* @param _index index of the token
* @return true if the user has borrowed the token
*/
function isUserHasBorrows(address _account, uint8 _index) public view returns (bool) {
Account storage account = accounts[_account];
return account.borrowBitmap.isBitSet(_index);
}
/**
* Check if the user has collateral flag set
* @param _account address of the user
* @param _index index of the token
* @return true if the user has collateral flag set for the given index
*/
function isUserHasCollateral(address _account, uint8 _index) public view returns(bool) {
Account storage account = accounts[_account];
return account.collateralBitmap.isBitSet(_index);
}
/**
* Set the deposit bitmap for a token.
* @param _account address of the user
* @param _index index of the token
*/
function setInDepositBitmap(address _account, uint8 _index) internal {
Account storage account = accounts[_account];
account.depositBitmap = account.depositBitmap.setBit(_index);
}
/**
* Unset the deposit bitmap for a token
* @param _account address of the user
* @param _index index of the token
*/
function unsetFromDepositBitmap(address _account, uint8 _index) internal {
Account storage account = accounts[_account];
account.depositBitmap = account.depositBitmap.unsetBit(_index);
}
/**
* Set the borrow bitmap for a token.
* @param _account address of the user
* @param _index index of the token
*/
function setInBorrowBitmap(address _account, uint8 _index) internal {
Account storage account = accounts[_account];
account.borrowBitmap = account.borrowBitmap.setBit(_index);
}
/**
* Unset the borrow bitmap for a token
* @param _account address of the user
* @param _index index of the token
*/
function unsetFromBorrowBitmap(address _account, uint8 _index) internal {
Account storage account = accounts[_account];
account.borrowBitmap = account.borrowBitmap.unsetBit(_index);
}
function getDepositPrincipal(address _accountAddr, address _token) public view returns(uint256) {
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
return tokenInfo.getDepositPrincipal();
}
function getBorrowPrincipal(address _accountAddr, address _token) public view returns(uint256) {
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
return tokenInfo.getBorrowPrincipal();
}
function getLastDepositBlock(address _accountAddr, address _token) public view returns(uint256) {
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
return tokenInfo.getLastDepositBlock();
}
function getLastBorrowBlock(address _accountAddr, address _token) public view returns(uint256) {
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
return tokenInfo.getLastBorrowBlock();
}
/**
* Get deposit interest of an account for a specific token
* @param _account account address
* @param _token token address
* @dev The deposit interest may not have been updated in AccountTokenLib, so we need to explicited calcuate it.
*/
function getDepositInterest(address _account, address _token) public view returns(uint256) {
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_account].tokenInfos[_token];
// If the account has never deposited the token, return 0.
uint256 lastDepositBlock = tokenInfo.getLastDepositBlock();
if (lastDepositBlock == 0)
return 0;
else {
// As the last deposit block exists, the block is also a check point on index curve.
uint256 accruedRate = globalConfig.bank().getDepositAccruedRate(_token, lastDepositBlock);
return tokenInfo.calculateDepositInterest(accruedRate);
}
}
function getBorrowInterest(address _accountAddr, address _token) public view returns(uint256) {
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
// If the account has never borrowed the token, return 0
uint256 lastBorrowBlock = tokenInfo.getLastBorrowBlock();
if (lastBorrowBlock == 0)
return 0;
else {
// As the last borrow block exists, the block is also a check point on index curve.
uint256 accruedRate = globalConfig.bank().getBorrowAccruedRate(_token, lastBorrowBlock);
return tokenInfo.calculateBorrowInterest(accruedRate);
}
}
function borrow(address _accountAddr, address _token, uint256 _amount) external onlyAuthorized {
initCollateralFlag(_accountAddr);
require(_amount != 0, "borrow amount is 0");
require(isUserHasAnyDeposits(_accountAddr), "no user deposits");
(uint8 tokenIndex, uint256 tokenDivisor, uint256 tokenPrice,) = globalConfig.tokenInfoRegistry().getTokenInfoFromAddress(_token);
require(
getBorrowETH(_accountAddr).add(_amount.mul(tokenPrice).div(tokenDivisor)) <=
getBorrowPower(_accountAddr), "Insufficient collateral when borrow"
);
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
uint256 blockNumber = getBlockNumber();
uint256 lastBorrowBlock = tokenInfo.getLastBorrowBlock();
if(lastBorrowBlock == 0)
tokenInfo.borrow(_amount, INT_UNIT, blockNumber);
else {
calculateBorrowFIN(lastBorrowBlock, _token, _accountAddr, blockNumber);
uint256 accruedRate = globalConfig.bank().getBorrowAccruedRate(_token, lastBorrowBlock);
// Update the token principla and interest
tokenInfo.borrow(_amount, accruedRate, blockNumber);
}
// Since we have checked that borrow amount is larget than zero. We can set the borrow
// map directly without checking the borrow balance.
setInBorrowBitmap(_accountAddr, tokenIndex);
}
/**
* Update token info for withdraw. The interest will be withdrawn with higher priority.
*/
function withdraw(address _accountAddr, address _token, uint256 _amount) public onlyAuthorized returns (uint256) {
initCollateralFlag(_accountAddr);
(, uint256 tokenDivisor, uint256 tokenPrice, uint256 borrowLTV) = globalConfig.tokenInfoRegistry().getTokenInfoFromAddress(_token);
// if user borrowed before then only check for under liquidation
Account memory account = accounts[_accountAddr];
if(account.borrowBitmap > 0) {
uint256 withdrawETH = _amount.mul(tokenPrice).mul(borrowLTV).div(tokenDivisor).div(100);
require(getBorrowETH(_accountAddr) <= getBorrowPower(_accountAddr).sub(withdrawETH), "Insufficient collateral");
}
(uint256 amountAfterCommission, ) = _withdraw(_accountAddr, _token, _amount, true);
return amountAfterCommission;
}
/**
* This function is called in liquidation function. There two difference between this function and
* the Account.withdraw function: 1) It doesn't check the user's borrow power, because the user
* is already borrowed more than it's borrowing power. 2) It doesn't take commissions.
*/
function withdraw_liquidate(address _accountAddr, address _token, uint256 _amount) internal {
_withdraw(_accountAddr, _token, _amount, false);
}
function _withdraw(address _accountAddr, address _token, uint256 _amount, bool _isCommission) internal returns (uint256, uint256) {
uint256 calcAmount = _amount;
// Check if withdraw amount is less than user's balance
require(calcAmount <= getDepositBalanceCurrent(_token, _accountAddr), "Insufficient balance");
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
uint256 lastBlock = tokenInfo.getLastDepositBlock();
uint256 blockNumber = getBlockNumber();
calculateDepositFIN(lastBlock, _token, _accountAddr, blockNumber);
uint256 principalBeforeWithdraw = tokenInfo.getDepositPrincipal();
if (lastBlock == 0)
tokenInfo.withdraw(calcAmount, INT_UNIT, blockNumber);
else {
// As the last deposit block exists, the block is also a check point on index curve.
uint256 accruedRate = globalConfig.bank().getDepositAccruedRate(_token, lastBlock);
tokenInfo.withdraw(calcAmount, accruedRate, blockNumber);
}
uint256 principalAfterWithdraw = tokenInfo.getDepositPrincipal();
if(principalAfterWithdraw == 0) {
uint8 tokenIndex = globalConfig.tokenInfoRegistry().getTokenIndex(_token);
unsetFromDepositBitmap(_accountAddr, tokenIndex);
}
uint256 commission = 0;
if (_isCommission && _accountAddr != globalConfig.deFinerCommunityFund()) {
// DeFiner takes 10% commission on the interest a user earn
commission = calcAmount.sub(principalBeforeWithdraw.sub(principalAfterWithdraw)).mul(globalConfig.deFinerRate()).div(100);
deposit(globalConfig.deFinerCommunityFund(), _token, commission);
calcAmount = calcAmount.sub(commission);
}
return (calcAmount, commission);
}
/**
* Update token info for deposit
*/
function deposit(address _accountAddr, address _token, uint256 _amount) public onlyAuthorized {
initCollateralFlag(_accountAddr);
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
if(tokenInfo.getDepositPrincipal() == 0) {
uint8 tokenIndex = globalConfig.tokenInfoRegistry().getTokenIndex(_token);
setInDepositBitmap(_accountAddr, tokenIndex);
}
uint256 blockNumber = getBlockNumber();
uint256 lastDepositBlock = tokenInfo.getLastDepositBlock();
if(lastDepositBlock == 0)
tokenInfo.deposit(_amount, INT_UNIT, blockNumber);
else {
calculateDepositFIN(lastDepositBlock, _token, _accountAddr, blockNumber);
uint256 accruedRate = globalConfig.bank().getDepositAccruedRate(_token, lastDepositBlock);
tokenInfo.deposit(_amount, accruedRate, blockNumber);
}
}
function repay(address _accountAddr, address _token, uint256 _amount) public onlyAuthorized returns(uint256){
initCollateralFlag(_accountAddr);
// Update tokenInfo
uint256 amountOwedWithInterest = getBorrowBalanceCurrent(_token, _accountAddr);
uint256 amount = _amount > amountOwedWithInterest ? amountOwedWithInterest : _amount;
uint256 remain = _amount > amountOwedWithInterest ? _amount.sub(amountOwedWithInterest) : 0;
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
// Sanity check
uint256 borrowPrincipal = tokenInfo.getBorrowPrincipal();
uint256 lastBorrowBlock = tokenInfo.getLastBorrowBlock();
require(borrowPrincipal > 0, "BorrowPrincipal not gt 0");
if(lastBorrowBlock == 0)
tokenInfo.repay(amount, INT_UNIT, getBlockNumber());
else {
calculateBorrowFIN(lastBorrowBlock, _token, _accountAddr, getBlockNumber());
uint256 accruedRate = globalConfig.bank().getBorrowAccruedRate(_token, lastBorrowBlock);
tokenInfo.repay(amount, accruedRate, getBlockNumber());
}
if(borrowPrincipal == 0) {
uint8 tokenIndex = globalConfig.tokenInfoRegistry().getTokenIndex(_token);
unsetFromBorrowBitmap(_accountAddr, tokenIndex);
}
return remain;
}
function getDepositBalanceCurrent(
address _token,
address _accountAddr
) public view returns (uint256 depositBalance) {
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
Bank bank = globalConfig.bank();
uint256 accruedRate;
uint256 depositRateIndex = bank.depositeRateIndex(_token, tokenInfo.getLastDepositBlock());
if(tokenInfo.getDepositPrincipal() == 0) {
return 0;
} else {
if(depositRateIndex == 0) {
accruedRate = INT_UNIT;
} else {
accruedRate = bank.depositeRateIndexNow(_token)
.mul(INT_UNIT)
.div(depositRateIndex);
}
return tokenInfo.getDepositBalance(accruedRate);
}
}
/**
* Get current borrow balance of a token
* @param _token token address
* @dev This is an estimation. Add a new checkpoint first, if you want to derive the exact balance.
*/
function getBorrowBalanceCurrent(
address _token,
address _accountAddr
) public view returns (uint256 borrowBalance) {
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
Bank bank = globalConfig.bank();
uint256 accruedRate;
uint256 borrowRateIndex = bank.borrowRateIndex(_token, tokenInfo.getLastBorrowBlock());
if(tokenInfo.getBorrowPrincipal() == 0) {
return 0;
} else {
if(borrowRateIndex == 0) {
accruedRate = INT_UNIT;
} else {
accruedRate = bank.borrowRateIndexNow(_token)
.mul(INT_UNIT)
.div(borrowRateIndex);
}
return tokenInfo.getBorrowBalance(accruedRate);
}
}
/**
* Calculate an account's borrow power based on token's LTV
*/
/*
function getBorrowPower(address _borrower) public view returns (uint256 power) {
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
uint256 tokenNum = tokenRegistry.getCoinLength();
for(uint256 i = 0; i < tokenNum; i++) {
if (isUserHasDeposits(_borrower, uint8(i))) {
(address token, uint256 divisor, uint256 price, uint256 borrowLTV) = tokenRegistry.getTokenInfoFromIndex(i);
uint256 depositBalanceCurrent = getDepositBalanceCurrent(token, _borrower);
power = power.add(depositBalanceCurrent.mul(price).mul(borrowLTV).div(100).div(divisor));
}
}
return power;
}
*/
function getBorrowPower(address _borrower) public view returns (uint256 power) {
Account storage account = accounts[_borrower];
// if a user have deposits in some tokens and collateral enabled for some
// then we need to iterate over his deposits for which collateral is also enabled.
// Hence, we can derive this information by perorming AND bitmap operation
// hasCollnDepositBitmap = collateralEnabled & hasDeposit
// Example:
// collateralBitmap = 0101
// depositBitmap = 0110
// ================================== OP AND
// hasCollnDepositBitmap = 0100 (user can only use his 3rd token as borrow power)
uint128 hasCollnDepositBitmap = account.collateralBitmap & account.depositBitmap;
// When no-collateral enabled and no-deposits just return '0' power
if(hasCollnDepositBitmap == 0) return power;
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
// This loop has max "O(n)" complexity where "n = TokensLength", but the loop
// calculates borrow power only for the `hasCollnDepositBitmap` bit, hence the loop
// iterates only till the highest bit set. Example 00000100, the loop will iterate
// only for 4 times, and only 1 time to calculate borrow the power.
// NOTE: When transaction gas-cost goes above the block gas limit, a user can
// disable some of his collaterals so that he can perform the borrow.
// Earlier loop implementation was iterating over all tokens, hence the platform
// were not able to add new tokens
for(uint i = 0; i < 128; i++) {
// if hasCollnDepositBitmap = 0000 then break the loop
if(hasCollnDepositBitmap > 0) {
// hasCollnDepositBitmap = 0100
// mask = 0001
// =============================== OP AND
// result = 0000
bool isEnabled = (hasCollnDepositBitmap & uint128(1)) > 0;
// Is i(th) token enabled?
if(isEnabled) {
// continue calculating borrow power for i(th) token
(address token, uint256 divisor, uint256 price, uint256 borrowLTV) = tokenRegistry.getTokenInfoFromIndex(i);
// avoid some gas consumption when borrowLTV == 0
if(borrowLTV != 0) {
uint256 depositBalanceCurrent = getDepositBalanceCurrent(token, _borrower);
power = power.add(depositBalanceCurrent.mul(price).mul(borrowLTV).div(100).div(divisor));
}
}
// right shift by 1
// hasCollnDepositBitmap = 0100
// BITWISE RIGHTSHIFT 1 on hasCollnDepositBitmap = 0010
hasCollnDepositBitmap = hasCollnDepositBitmap >> 1;
// continue loop and repeat the steps until `hasCollnDepositBitmap == 0`
} else {
break;
}
}
return power;
}
function getCollateralETH(address _account) public view returns (uint256 collETH) {
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
Account memory account = accounts[_account];
uint128 hasDeposits = account.depositBitmap;
for(uint8 i = 0; i < 128; i++) {
if(hasDeposits > 0) {
bool isEnabled = (hasDeposits & uint128(1)) > 0;
if(isEnabled) {
(address token,
uint256 divisor,
uint256 price,
uint256 borrowLTV) = tokenRegistry.getTokenInfoFromIndex(i);
if(borrowLTV != 0) {
uint256 depositBalanceCurrent = getDepositBalanceCurrent(token, _account);
collETH = collETH.add(depositBalanceCurrent.mul(price).div(divisor));
}
}
hasDeposits = hasDeposits >> 1;
} else {
break;
}
}
return collETH;
}
/**
* Get current deposit balance of a token
* @dev This is an estimation. Add a new checkpoint first, if you want to derive the exact balance.
*/
function getDepositETH(
address _accountAddr
) public view returns (uint256 depositETH) {
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
Account memory account = accounts[_accountAddr];
uint128 hasDeposits = account.depositBitmap;
for(uint8 i = 0; i < 128; i++) {
if(hasDeposits > 0) {
bool isEnabled = (hasDeposits & uint128(1)) > 0;
if(isEnabled) {
(address token, uint256 divisor, uint256 price, ) = tokenRegistry.getTokenInfoFromIndex(i);
uint256 depositBalanceCurrent = getDepositBalanceCurrent(token, _accountAddr);
depositETH = depositETH.add(depositBalanceCurrent.mul(price).div(divisor));
}
hasDeposits = hasDeposits >> 1;
} else {
break;
}
}
return depositETH;
}
/**
* Get borrowed balance of a token in the uint256 of Wei
*/
function getBorrowETH(
address _accountAddr
) public view returns (uint256 borrowETH) {
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
Account memory account = accounts[_accountAddr];
uint128 hasBorrows = account.borrowBitmap;
for(uint8 i = 0; i < 128; i++) {
if(hasBorrows > 0) {
bool isEnabled = (hasBorrows & uint128(1)) > 0;
if(isEnabled) {
(address token, uint256 divisor, uint256 price, ) = tokenRegistry.getTokenInfoFromIndex(i);
uint256 borrowBalanceCurrent = getBorrowBalanceCurrent(token, _accountAddr);
borrowETH = borrowETH.add(borrowBalanceCurrent.mul(price).div(divisor));
}
hasBorrows = hasBorrows >> 1;
} else {
break;
}
}
return borrowETH;
}
/**
* Check if the account is liquidatable
* @param _borrower borrower's account
* @return true if the account is liquidatable
*/
function isAccountLiquidatable(address _borrower) public returns (bool) {
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
Bank bank = globalConfig.bank();
// Add new rate check points for all the collateral tokens from borrower in order to
// have accurate calculation of liquidation oppotunites.
Account memory account = accounts[_borrower];
uint128 hasBorrowsOrDeposits = account.borrowBitmap | account.depositBitmap;
for(uint8 i = 0; i < 128; i++) {
if(hasBorrowsOrDeposits > 0) {
bool isEnabled = (hasBorrowsOrDeposits & uint128(1)) > 0;
if(isEnabled) {
address token = tokenRegistry.addressFromIndex(i);
bank.newRateIndexCheckpoint(token);
}
hasBorrowsOrDeposits = hasBorrowsOrDeposits >> 1;
} else {
break;
}
}
uint256 liquidationThreshold = globalConfig.liquidationThreshold();
uint256 totalBorrow = getBorrowETH(_borrower);
uint256 totalCollateral = getCollateralETH(_borrower);
// It is required that LTV is larger than LIQUIDATE_THREADHOLD for liquidation
// return totalBorrow.mul(100) > totalCollateral.mul(liquidationThreshold);
return totalBorrow.mul(100) > totalCollateral.mul(liquidationThreshold);
}
struct LiquidationVars {
uint256 borrowerCollateralValue;
uint256 targetTokenBalance;
uint256 targetTokenBalanceBorrowed;
uint256 targetTokenPrice;
uint256 liquidationDiscountRatio;
uint256 totalBorrow;
uint256 borrowPower;
uint256 liquidateTokenBalance;
uint256 liquidateTokenPrice;
uint256 limitRepaymentValue;
uint256 borrowTokenLTV;
uint256 repayAmount;
uint256 payAmount;
}
function liquidate(
address _liquidator,
address _borrower,
address _borrowedToken,
address _collateralToken
)
external
onlyAuthorized
returns (
uint256,
uint256
)
{
initCollateralFlag(_liquidator);
initCollateralFlag(_borrower);
require(isAccountLiquidatable(_borrower), "borrower is not liquidatable");
// It is required that the liquidator doesn't exceed it's borrow power.
// if liquidator has any borrows, then only check for borrowPower condition
Account memory liquidateAcc = accounts[_liquidator];
if(liquidateAcc.borrowBitmap > 0) {
require(
getBorrowETH(_liquidator) < getBorrowPower(_liquidator),
"No extra funds used for liquidation"
);
}
LiquidationVars memory vars;
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
// _borrowedToken balance of the liquidator (deposit balance)
vars.targetTokenBalance = getDepositBalanceCurrent(_borrowedToken, _liquidator);
require(vars.targetTokenBalance > 0, "amount must be > 0");
// _borrowedToken balance of the borrower (borrow balance)
vars.targetTokenBalanceBorrowed = getBorrowBalanceCurrent(_borrowedToken, _borrower);
require(vars.targetTokenBalanceBorrowed > 0, "borrower not own any debt token");
// _borrowedToken available for liquidation
uint256 borrowedTokenAmountForLiquidation = vars.targetTokenBalance.min(vars.targetTokenBalanceBorrowed);
// _collateralToken balance of the borrower (deposit balance)
vars.liquidateTokenBalance = getDepositBalanceCurrent(_collateralToken, _borrower);
uint256 targetTokenDivisor;
(
,
targetTokenDivisor,
vars.targetTokenPrice,
vars.borrowTokenLTV
) = tokenRegistry.getTokenInfoFromAddress(_borrowedToken);
uint256 liquidateTokendivisor;
uint256 collateralLTV;
(
,
liquidateTokendivisor,
vars.liquidateTokenPrice,
collateralLTV
) = tokenRegistry.getTokenInfoFromAddress(_collateralToken);
// _collateralToken to purchase so that borrower's balance matches its borrow power
vars.totalBorrow = getBorrowETH(_borrower);
vars.borrowPower = getBorrowPower(_borrower);
vars.liquidationDiscountRatio = globalConfig.liquidationDiscountRatio();
vars.limitRepaymentValue = vars.totalBorrow.sub(vars.borrowPower)
.mul(100)
.div(vars.liquidationDiscountRatio.sub(collateralLTV));
uint256 collateralTokenValueForLiquidation = vars.limitRepaymentValue.min(
vars.liquidateTokenBalance
.mul(vars.liquidateTokenPrice)
.div(liquidateTokendivisor)
);
uint256 liquidationValue = collateralTokenValueForLiquidation.min(
borrowedTokenAmountForLiquidation
.mul(vars.targetTokenPrice)
.mul(100)
.div(targetTokenDivisor)
.div(vars.liquidationDiscountRatio)
);
vars.repayAmount = liquidationValue.mul(vars.liquidationDiscountRatio)
.mul(targetTokenDivisor)
.div(100)
.div(vars.targetTokenPrice);
vars.payAmount = vars.repayAmount.mul(liquidateTokendivisor)
.mul(100)
.mul(vars.targetTokenPrice);
vars.payAmount = vars.payAmount.div(targetTokenDivisor)
.div(vars.liquidationDiscountRatio)
.div(vars.liquidateTokenPrice);
deposit(_liquidator, _collateralToken, vars.payAmount);
withdraw_liquidate(_liquidator, _borrowedToken, vars.repayAmount);
withdraw_liquidate(_borrower, _collateralToken, vars.payAmount);
repay(_borrower, _borrowedToken, vars.repayAmount);
return (vars.repayAmount, vars.payAmount);
}
/**
* Get current block number
* @return the current block number
*/
function getBlockNumber() private view returns (uint256) {
return block.number;
}
/**
* An account claim all mined FIN token.
* @dev If the FIN mining index point doesn't exist, we have to calculate the FIN amount
* accurately. So the user can withdraw all available FIN tokens.
*/
function claim(address _account) public onlyAuthorized returns(uint256){
TokenRegistry tokenRegistry = globalConfig.tokenInfoRegistry();
Bank bank = globalConfig.bank();
uint256 currentBlock = getBlockNumber();
Account memory account = accounts[_account];
uint128 depositBitmap = account.depositBitmap;
uint128 borrowBitmap = account.borrowBitmap;
uint128 hasDepositOrBorrow = depositBitmap | borrowBitmap;
for(uint8 i = 0; i < 128; i++) {
if(hasDepositOrBorrow > 0) {
if((hasDepositOrBorrow & uint128(1)) > 0) {
address token = tokenRegistry.addressFromIndex(i);
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_account].tokenInfos[token];
bank.updateMining(token);
if (depositBitmap.isBitSet(i)) {
bank.updateDepositFINIndex(token);
uint256 lastDepositBlock = tokenInfo.getLastDepositBlock();
calculateDepositFIN(lastDepositBlock, token, _account, currentBlock);
tokenInfo.deposit(0, bank.getDepositAccruedRate(token, lastDepositBlock), currentBlock);
}
if (borrowBitmap.isBitSet(i)) {
bank.updateBorrowFINIndex(token);
uint256 lastBorrowBlock = tokenInfo.getLastBorrowBlock();
calculateBorrowFIN(lastBorrowBlock, token, _account, currentBlock);
tokenInfo.borrow(0, bank.getBorrowAccruedRate(token, lastBorrowBlock), currentBlock);
}
}
hasDepositOrBorrow = hasDepositOrBorrow >> 1;
} else {
break;
}
}
uint256 _FINAmount = FINAmount[_account];
FINAmount[_account] = 0;
return _FINAmount;
}
function claimForToken(address _account, address _token) public onlyAuthorized returns(uint256) {
Account memory account = accounts[_account];
uint8 index = globalConfig.tokenInfoRegistry().getTokenIndex(_token);
bool isDeposit = account.depositBitmap.isBitSet(index);
bool isBorrow = account.borrowBitmap.isBitSet(index);
if(! (isDeposit || isBorrow)) return 0;
Bank bank = globalConfig.bank();
uint256 currentBlock = getBlockNumber();
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_account].tokenInfos[_token];
bank.updateMining(_token);
if (isDeposit) {
bank.updateDepositFINIndex(_token);
uint256 lastDepositBlock = tokenInfo.getLastDepositBlock();
calculateDepositFIN(lastDepositBlock, _token, _account, currentBlock);
tokenInfo.deposit(0, bank.getDepositAccruedRate(_token, lastDepositBlock), currentBlock);
}
if (isBorrow) {
bank.updateBorrowFINIndex(_token);
uint256 lastBorrowBlock = tokenInfo.getLastBorrowBlock();
calculateBorrowFIN(lastBorrowBlock, _token, _account, currentBlock);
tokenInfo.borrow(0, bank.getBorrowAccruedRate(_token, lastBorrowBlock), currentBlock);
}
uint256 _FINAmount = FINAmount[_account];
FINAmount[_account] = 0;
return _FINAmount;
}
/**
* Accumulate the amount FIN mined by depositing between _lastBlock and _currentBlock
*/
function calculateDepositFIN(uint256 _lastBlock, address _token, address _accountAddr, uint256 _currentBlock) internal {
Bank bank = globalConfig.bank();
uint256 indexDifference = bank.depositFINRateIndex(_token, _currentBlock)
.sub(bank.depositFINRateIndex(_token, _lastBlock));
uint256 getFIN = getDepositBalanceCurrent(_token, _accountAddr)
.mul(indexDifference)
.div(bank.depositeRateIndex(_token, _currentBlock));
FINAmount[_accountAddr] = FINAmount[_accountAddr].add(getFIN);
}
/**
* Accumulate the amount FIN mined by borrowing between _lastBlock and _currentBlock
*/
function calculateBorrowFIN(uint256 _lastBlock, address _token, address _accountAddr, uint256 _currentBlock) internal {
Bank bank = globalConfig.bank();
uint256 indexDifference = bank.borrowFINRateIndex(_token, _currentBlock)
.sub(bank.borrowFINRateIndex(_token, _lastBlock));
uint256 getFIN = getBorrowBalanceCurrent(_token, _accountAddr)
.mul(indexDifference)
.div(bank.borrowRateIndex(_token, _currentBlock));
FINAmount[_accountAddr] = FINAmount[_accountAddr].add(getFIN);
}
function version() public pure returns(string memory) {
return "v1.2.0";
}
}
contract GlobalConfig is Ownable {
using SafeMath for uint256;
uint256 public communityFundRatio = 20;
uint256 public minReserveRatio = 10;
uint256 public maxReserveRatio = 20;
uint256 public liquidationThreshold = 85;
uint256 public liquidationDiscountRatio = 95;
uint256 public compoundSupplyRateWeights = 1;
uint256 public compoundBorrowRateWeights = 9;
uint256 public rateCurveSlope = 0;
uint256 public rateCurveConstant = 4 * 10 ** 16;
uint256 public deFinerRate = 25;
address payable public deFinerCommunityFund = 0xC0fd76eDcb8893a83c293ed06a362b1c18a584C7;
Bank public bank; // the Bank contract
SavingAccount public savingAccount; // the SavingAccount contract
TokenRegistry public tokenInfoRegistry; // the TokenRegistry contract
Accounts public accounts; // the Accounts contract
Constant public constants; // the constants contract
event CommunityFundRatioUpdated(uint256 indexed communityFundRatio);
event MinReserveRatioUpdated(uint256 indexed minReserveRatio);
event MaxReserveRatioUpdated(uint256 indexed maxReserveRatio);
event LiquidationThresholdUpdated(uint256 indexed liquidationThreshold);
event LiquidationDiscountRatioUpdated(uint256 indexed liquidationDiscountRatio);
event CompoundSupplyRateWeightsUpdated(uint256 indexed compoundSupplyRateWeights);
event CompoundBorrowRateWeightsUpdated(uint256 indexed compoundBorrowRateWeights);
event rateCurveSlopeUpdated(uint256 indexed rateCurveSlope);
event rateCurveConstantUpdated(uint256 indexed rateCurveConstant);
event ConstantUpdated(address indexed constants);
event BankUpdated(address indexed bank);
event SavingAccountUpdated(address indexed savingAccount);
event TokenInfoRegistryUpdated(address indexed tokenInfoRegistry);
event AccountsUpdated(address indexed accounts);
event DeFinerCommunityFundUpdated(address indexed deFinerCommunityFund);
event DeFinerRateUpdated(uint256 indexed deFinerRate);
event ChainLinkUpdated(address indexed chainLink);
function initialize(
Bank _bank,
SavingAccount _savingAccount,
TokenRegistry _tokenInfoRegistry,
Accounts _accounts,
Constant _constants
) public onlyOwner {
bank = _bank;
savingAccount = _savingAccount;
tokenInfoRegistry = _tokenInfoRegistry;
accounts = _accounts;
constants = _constants;
}
/**
* Update the community fund (commision fee) ratio.
* @param _communityFundRatio the new ratio
*/
function updateCommunityFundRatio(uint256 _communityFundRatio) external onlyOwner {
if (_communityFundRatio == communityFundRatio)
return;
require(_communityFundRatio > 0 && _communityFundRatio < 100,
"Invalid community fund ratio.");
communityFundRatio = _communityFundRatio;
emit CommunityFundRatioUpdated(_communityFundRatio);
}
/**
* Update the minimum reservation reatio
* @param _minReserveRatio the new value of the minimum reservation ratio
*/
function updateMinReserveRatio(uint256 _minReserveRatio) external onlyOwner {
if (_minReserveRatio == minReserveRatio)
return;
require(_minReserveRatio > 0 && _minReserveRatio < maxReserveRatio,
"Invalid min reserve ratio.");
minReserveRatio = _minReserveRatio;
emit MinReserveRatioUpdated(_minReserveRatio);
}
/**
* Update the maximum reservation reatio
* @param _maxReserveRatio the new value of the maximum reservation ratio
*/
function updateMaxReserveRatio(uint256 _maxReserveRatio) external onlyOwner {
if (_maxReserveRatio == maxReserveRatio)
return;
require(_maxReserveRatio > minReserveRatio && _maxReserveRatio < 100,
"Invalid max reserve ratio.");
maxReserveRatio = _maxReserveRatio;
emit MaxReserveRatioUpdated(_maxReserveRatio);
}
/**
* Update the liquidation threshold, i.e. the LTV that will trigger the liquidation.
* @param _liquidationThreshold the new threshhold value
*/
function updateLiquidationThreshold(uint256 _liquidationThreshold) external onlyOwner {
if (_liquidationThreshold == liquidationThreshold)
return;
require(_liquidationThreshold > 0 && _liquidationThreshold < liquidationDiscountRatio,
"Invalid liquidation threshold.");
liquidationThreshold = _liquidationThreshold;
emit LiquidationThresholdUpdated(_liquidationThreshold);
}
/**
* Update the liquidation discount
* @param _liquidationDiscountRatio the new liquidation discount
*/
function updateLiquidationDiscountRatio(uint256 _liquidationDiscountRatio) external onlyOwner {
if (_liquidationDiscountRatio == liquidationDiscountRatio)
return;
require(_liquidationDiscountRatio > liquidationThreshold && _liquidationDiscountRatio < 100,
"Invalid liquidation discount ratio.");
liquidationDiscountRatio = _liquidationDiscountRatio;
emit LiquidationDiscountRatioUpdated(_liquidationDiscountRatio);
}
/**
* Medium value of the reservation ratio, which is the value that the pool try to maintain.
*/
function midReserveRatio() public view returns(uint256){
return minReserveRatio.add(maxReserveRatio).div(2);
}
function updateCompoundSupplyRateWeights(uint256 _compoundSupplyRateWeights) external onlyOwner{
compoundSupplyRateWeights = _compoundSupplyRateWeights;
emit CompoundSupplyRateWeightsUpdated(_compoundSupplyRateWeights);
}
function updateCompoundBorrowRateWeights(uint256 _compoundBorrowRateWeights) external onlyOwner{
compoundBorrowRateWeights = _compoundBorrowRateWeights;
emit CompoundBorrowRateWeightsUpdated(_compoundBorrowRateWeights);
}
function updaterateCurveSlope(uint256 _rateCurveSlope) external onlyOwner{
rateCurveSlope = _rateCurveSlope;
emit rateCurveSlopeUpdated(_rateCurveSlope);
}
function updaterateCurveConstant(uint256 _rateCurveConstant) external onlyOwner{
rateCurveConstant = _rateCurveConstant;
emit rateCurveConstantUpdated(_rateCurveConstant);
}
function updateBank(Bank _bank) external onlyOwner{
bank = _bank;
emit BankUpdated(address(_bank));
}
function updateSavingAccount(SavingAccount _savingAccount) external onlyOwner{
savingAccount = _savingAccount;
emit SavingAccountUpdated(address(_savingAccount));
}
function updateTokenInfoRegistry(TokenRegistry _tokenInfoRegistry) external onlyOwner{
tokenInfoRegistry = _tokenInfoRegistry;
emit TokenInfoRegistryUpdated(address(_tokenInfoRegistry));
}
function updateAccounts(Accounts _accounts) external onlyOwner{
accounts = _accounts;
emit AccountsUpdated(address(_accounts));
}
function updateConstant(Constant _constants) external onlyOwner{
constants = _constants;
emit ConstantUpdated(address(_constants));
}
function updatedeFinerCommunityFund(address payable _deFinerCommunityFund) external onlyOwner{
deFinerCommunityFund = _deFinerCommunityFund;
emit DeFinerCommunityFundUpdated(_deFinerCommunityFund);
}
function updatedeFinerRate(uint256 _deFinerRate) external onlyOwner{
require(_deFinerRate <= 100,"_deFinerRate cannot exceed 100");
deFinerRate = _deFinerRate;
emit DeFinerRateUpdated(_deFinerRate);
}
}
interface ICToken {
function supplyRatePerBlock() external view returns (uint);
function borrowRatePerBlock() external view returns (uint);
function mint(uint mintAmount) external returns (uint);
function redeemUnderlying(uint redeemAmount) external returns (uint);
function redeem(uint redeemAmount) external returns (uint);
function exchangeRateStore() external view returns (uint);
function exchangeRateCurrent() external returns (uint);
function balanceOf(address owner) external view returns (uint256);
function balanceOfUnderlying(address owner) external returns (uint);
}
interface ICETH{
function mint() external payable;
}
interface IController {
function fastForward(uint blocks) external returns (uint);
function getBlockNumber() external view returns (uint);
}
contract Bank is Constant, Initializable{
using SafeMath for uint256;
mapping(address => uint256) public totalLoans; // amount of lended tokens
mapping(address => uint256) public totalReserve; // amount of tokens in reservation
mapping(address => uint256) public totalCompound; // amount of tokens in compound
// Token => block-num => rate
mapping(address => mapping(uint => uint)) public depositeRateIndex; // the index curve of deposit rate
// Token => block-num => rate
mapping(address => mapping(uint => uint)) public borrowRateIndex; // the index curve of borrow rate
// token address => block number
mapping(address => uint) public lastCheckpoint; // last checkpoint on the index curve
// cToken address => rate
mapping(address => uint) public lastCTokenExchangeRate; // last compound cToken exchange rate
mapping(address => ThirdPartyPool) compoundPool; // the compound pool
GlobalConfig globalConfig; // global configuration contract address
mapping(address => mapping(uint => uint)) public depositFINRateIndex;
mapping(address => mapping(uint => uint)) public borrowFINRateIndex;
mapping(address => uint) public lastDepositFINRateCheckpoint;
mapping(address => uint) public lastBorrowFINRateCheckpoint;
modifier onlyAuthorized() {
require(msg.sender == address(globalConfig.savingAccount()) || msg.sender == address(globalConfig.accounts()),
"Only authorized to call from DeFiner internal contracts.");
_;
}
struct ThirdPartyPool {
bool supported; // if the token is supported by the third party platforms such as Compound
uint capitalRatio; // the ratio of the capital in third party to the total asset
uint depositRatePerBlock; // the deposit rate of the token in third party
uint borrowRatePerBlock; // the borrow rate of the token in third party
}
event UpdateIndex(address indexed token, uint256 depositeRateIndex, uint256 borrowRateIndex);
event UpdateDepositFINIndex(address indexed _token, uint256 depositFINRateIndex);
event UpdateBorrowFINIndex(address indexed _token, uint256 borrowFINRateIndex);
/**
* Initialize the Bank
* @param _globalConfig the global configuration contract
*/
function initialize(
GlobalConfig _globalConfig
) public initializer {
globalConfig = _globalConfig;
}
/**
* Total amount of the token in Saving account
* @param _token token address
*/
function getTotalDepositStore(address _token) public view returns(uint) {
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
// totalLoans[_token] = U totalReserve[_token] = R
return totalCompound[cToken].add(totalLoans[_token]).add(totalReserve[_token]); // return totalAmount = C + U + R
}
/**
* Update total amount of token in Compound as the cToken price changed
* @param _token token address
*/
function updateTotalCompound(address _token) internal {
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
if(cToken != address(0)) {
totalCompound[cToken] = ICToken(cToken).balanceOfUnderlying(address(globalConfig.savingAccount()));
}
}
/**
* Update the total reservation. Before run this function, make sure that totalCompound has been updated
* by calling updateTotalCompound. Otherwise, totalCompound may not equal to the exact amount of the
* token in Compound.
* @param _token token address
* @param _action indicate if user's operation is deposit or withdraw, and borrow or repay.
* @return the actuall amount deposit/withdraw from the saving pool
*/
function updateTotalReserve(address _token, uint _amount, ActionType _action) internal returns(uint256 compoundAmount){
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
uint totalAmount = getTotalDepositStore(_token);
if (_action == ActionType.DepositAction || _action == ActionType.RepayAction) {
// Total amount of token after deposit or repay
if (_action == ActionType.DepositAction)
totalAmount = totalAmount.add(_amount);
else
totalLoans[_token] = totalLoans[_token].sub(_amount);
// Expected total amount of token in reservation after deposit or repay
uint totalReserveBeforeAdjust = totalReserve[_token].add(_amount);
if (cToken != address(0) &&
totalReserveBeforeAdjust > totalAmount.mul(globalConfig.maxReserveRatio()).div(100)) {
uint toCompoundAmount = totalReserveBeforeAdjust.sub(totalAmount.mul(globalConfig.midReserveRatio()).div(100));
//toCompound(_token, toCompoundAmount);
compoundAmount = toCompoundAmount;
totalCompound[cToken] = totalCompound[cToken].add(toCompoundAmount);
totalReserve[_token] = totalReserve[_token].add(_amount).sub(toCompoundAmount);
}
else {
totalReserve[_token] = totalReserve[_token].add(_amount);
}
} else {
// The lack of liquidity exception happens when the pool doesn't have enough tokens for borrow/withdraw
// It happens when part of the token has lended to the other accounts.
// However in case of withdrawAll, even if the token has no loan, this requirment may still false because
// of the precision loss in the rate calcuation. So we put a logic here to deal with this case: in case
// of withdrawAll and there is no loans for the token, we just adjust the balance in bank contract to the
// to the balance of that individual account.
if(_action == ActionType.WithdrawAction) {
if(totalLoans[_token] != 0)
require(getPoolAmount(_token) >= _amount, "Lack of liquidity when withdraw.");
else if (getPoolAmount(_token) < _amount)
totalReserve[_token] = _amount.sub(totalCompound[cToken]);
totalAmount = getTotalDepositStore(_token);
}
else
require(getPoolAmount(_token) >= _amount, "Lack of liquidity when borrow.");
// Total amount of token after withdraw or borrow
if (_action == ActionType.WithdrawAction)
totalAmount = totalAmount.sub(_amount);
else
totalLoans[_token] = totalLoans[_token].add(_amount);
// Expected total amount of token in reservation after deposit or repay
uint totalReserveBeforeAdjust = totalReserve[_token] > _amount ? totalReserve[_token].sub(_amount) : 0;
// Trigger fromCompound if the new reservation ratio is less than 10%
if(cToken != address(0) &&
(totalAmount == 0 || totalReserveBeforeAdjust < totalAmount.mul(globalConfig.minReserveRatio()).div(100))) {
uint totalAvailable = totalReserve[_token].add(totalCompound[cToken]).sub(_amount);
if (totalAvailable < totalAmount.mul(globalConfig.midReserveRatio()).div(100)){
// Withdraw all the tokens from Compound
compoundAmount = totalCompound[cToken];
totalCompound[cToken] = 0;
totalReserve[_token] = totalAvailable;
} else {
// Withdraw partial tokens from Compound
uint totalInCompound = totalAvailable.sub(totalAmount.mul(globalConfig.midReserveRatio()).div(100));
compoundAmount = totalCompound[cToken].sub(totalInCompound);
totalCompound[cToken] = totalInCompound;
totalReserve[_token] = totalAvailable.sub(totalInCompound);
}
}
else {
totalReserve[_token] = totalReserve[_token].sub(_amount);
}
}
return compoundAmount;
}
function update(address _token, uint _amount, ActionType _action) public onlyAuthorized returns(uint256 compoundAmount) {
updateTotalCompound(_token);
// updateTotalLoan(_token);
compoundAmount = updateTotalReserve(_token, _amount, _action);
return compoundAmount;
}
/**
* The function is called in Bank.deposit(), Bank.withdraw() and Accounts.claim() functions.
* The function should be called AFTER the newRateIndexCheckpoint function so that the account balances are
* accurate, and BEFORE the account balance acutally updated due to deposit/withdraw activities.
*/
function updateDepositFINIndex(address _token) public onlyAuthorized{
uint currentBlock = getBlockNumber();
uint deltaBlock;
// If it is the first deposit FIN rate checkpoint, set the deltaBlock value be 0 so that the first
// point on depositFINRateIndex is zero.
deltaBlock = lastDepositFINRateCheckpoint[_token] == 0 ? 0 : currentBlock.sub(lastDepositFINRateCheckpoint[_token]);
// If the totalDeposit of the token is zero, no FIN token should be mined and the FINRateIndex is unchanged.
depositFINRateIndex[_token][currentBlock] = depositFINRateIndex[_token][lastDepositFINRateCheckpoint[_token]].add(
getTotalDepositStore(_token) == 0 ? 0 : depositeRateIndex[_token][lastCheckpoint[_token]]
.mul(deltaBlock)
.mul(globalConfig.tokenInfoRegistry().depositeMiningSpeeds(_token))
.div(getTotalDepositStore(_token)));
lastDepositFINRateCheckpoint[_token] = currentBlock;
emit UpdateDepositFINIndex(_token, depositFINRateIndex[_token][currentBlock]);
}
function updateBorrowFINIndex(address _token) public onlyAuthorized{
uint currentBlock = getBlockNumber();
uint deltaBlock;
// If it is the first borrow FIN rate checkpoint, set the deltaBlock value be 0 so that the first
// point on borrowFINRateIndex is zero.
deltaBlock = lastBorrowFINRateCheckpoint[_token] == 0 ? 0 : currentBlock.sub(lastBorrowFINRateCheckpoint[_token]);
// If the totalBorrow of the token is zero, no FIN token should be mined and the FINRateIndex is unchanged.
borrowFINRateIndex[_token][currentBlock] = borrowFINRateIndex[_token][lastBorrowFINRateCheckpoint[_token]].add(
totalLoans[_token] == 0 ? 0 : borrowRateIndex[_token][lastCheckpoint[_token]]
.mul(deltaBlock)
.mul(globalConfig.tokenInfoRegistry().borrowMiningSpeeds(_token))
.div(totalLoans[_token]));
lastBorrowFINRateCheckpoint[_token] = currentBlock;
emit UpdateBorrowFINIndex(_token, borrowFINRateIndex[_token][currentBlock]);
}
function updateMining(address _token) public onlyAuthorized{
newRateIndexCheckpoint(_token);
updateTotalCompound(_token);
}
/**
* Get the borrowing interest rate.
* @param _token token address
* @return the borrow rate for the current block
*/
function getBorrowRatePerBlock(address _token) public view returns(uint) {
uint256 capitalUtilizationRatio = getCapitalUtilizationRatio(_token);
// rateCurveConstant = <'3 * (10)^16'_rateCurveConstant_configurable>
uint256 rateCurveConstant = globalConfig.rateCurveConstant();
// compoundSupply = Compound Supply Rate * <'0.4'_supplyRateWeights_configurable>
uint256 compoundSupply = compoundPool[_token].depositRatePerBlock.mul(globalConfig.compoundSupplyRateWeights());
// compoundBorrow = Compound Borrow Rate * <'0.6'_borrowRateWeights_configurable>
uint256 compoundBorrow = compoundPool[_token].borrowRatePerBlock.mul(globalConfig.compoundBorrowRateWeights());
// nonUtilizedCapRatio = (1 - U) // Non utilized capital ratio
uint256 nonUtilizedCapRatio = INT_UNIT.sub(capitalUtilizationRatio);
bool isSupportedOnCompound = globalConfig.tokenInfoRegistry().isSupportedOnCompound(_token);
if(isSupportedOnCompound) {
uint256 compoundSupplyPlusBorrow = compoundSupply.add(compoundBorrow).div(10);
uint256 rateConstant;
// if the token is supported in third party (like Compound), check if U = 1
if(capitalUtilizationRatio > ((10**18) - (10**15))) { // > 0.999
// if U = 1, borrowing rate = compoundSupply + compoundBorrow + ((rateCurveConstant * 100) / BLOCKS_PER_YEAR)
rateConstant = rateCurveConstant.mul(1000).div(BLOCKS_PER_YEAR);
return compoundSupplyPlusBorrow.add(rateConstant);
} else {
// if U != 1, borrowing rate = compoundSupply + compoundBorrow + ((rateCurveConstant / (1 - U)) / BLOCKS_PER_YEAR)
rateConstant = rateCurveConstant.mul(10**18).div(nonUtilizedCapRatio).div(BLOCKS_PER_YEAR);
return compoundSupplyPlusBorrow.add(rateConstant);
}
} else {
// If the token is NOT supported by the third party, check if U = 1
if(capitalUtilizationRatio > ((10**18) - (10**15))) { // > 0.999
// if U = 1, borrowing rate = rateCurveConstant * 100
return rateCurveConstant.mul(1000).div(BLOCKS_PER_YEAR);
} else {
// if 0 < U < 1, borrowing rate = 3% / (1 - U)
return rateCurveConstant.mul(10**18).div(nonUtilizedCapRatio).div(BLOCKS_PER_YEAR);
}
}
}
/**
* Get Deposit Rate. Deposit APR = (Borrow APR * Utilization Rate (U) + Compound Supply Rate *
* Capital Compound Ratio (C) )* (1- DeFiner Community Fund Ratio (D)). The scaling is 10 ** 18
* @param _token token address
* @return deposite rate of blocks before the current block
*/
function getDepositRatePerBlock(address _token) public view returns(uint) {
uint256 borrowRatePerBlock = getBorrowRatePerBlock(_token);
uint256 capitalUtilRatio = getCapitalUtilizationRatio(_token);
if(!globalConfig.tokenInfoRegistry().isSupportedOnCompound(_token))
return borrowRatePerBlock.mul(capitalUtilRatio).div(INT_UNIT);
return borrowRatePerBlock.mul(capitalUtilRatio).add(compoundPool[_token].depositRatePerBlock
.mul(compoundPool[_token].capitalRatio)).div(INT_UNIT);
}
/**
* Get capital utilization. Capital Utilization Rate (U )= total loan outstanding / Total market deposit
* @param _token token address
* @return Capital utilization ratio `U`.
* Valid range: 0 ≤ U ≤ 10^18
*/
function getCapitalUtilizationRatio(address _token) public view returns(uint) {
uint256 totalDepositsNow = getTotalDepositStore(_token);
if(totalDepositsNow == 0) {
return 0;
} else {
return totalLoans[_token].mul(INT_UNIT).div(totalDepositsNow);
}
}
/**
* Ratio of the capital in Compound
* @param _token token address
*/
function getCapitalCompoundRatio(address _token) public view returns(uint) {
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
if(totalCompound[cToken] == 0 ) {
return 0;
} else {
return uint(totalCompound[cToken].mul(INT_UNIT).div(getTotalDepositStore(_token)));
}
}
/**
* It's a utility function. Get the cummulative deposit rate in a block interval ending in current block
* @param _token token address
* @param _depositRateRecordStart the start block of the interval
* @dev This function should always be called after current block is set as a new rateIndex point.
*/
function getDepositAccruedRate(address _token, uint _depositRateRecordStart) external view returns (uint256) {
uint256 depositRate = depositeRateIndex[_token][_depositRateRecordStart];
require(depositRate != 0, "_depositRateRecordStart is not a check point on index curve.");
return depositeRateIndexNow(_token).mul(INT_UNIT).div(depositRate);
}
/**
* Get the cummulative borrow rate in a block interval ending in current block
* @param _token token address
* @param _borrowRateRecordStart the start block of the interval
* @dev This function should always be called after current block is set as a new rateIndex point.
*/
function getBorrowAccruedRate(address _token, uint _borrowRateRecordStart) external view returns (uint256) {
uint256 borrowRate = borrowRateIndex[_token][_borrowRateRecordStart];
require(borrowRate != 0, "_borrowRateRecordStart is not a check point on index curve.");
return borrowRateIndexNow(_token).mul(INT_UNIT).div(borrowRate);
}
/**
* Set a new rate index checkpoint.
* @param _token token address
* @dev The rate set at the checkpoint is the rate from the last checkpoint to this checkpoint
*/
function newRateIndexCheckpoint(address _token) public onlyAuthorized {
// return if the rate check point already exists
uint blockNumber = getBlockNumber();
if (blockNumber == lastCheckpoint[_token])
return;
uint256 UNIT = INT_UNIT;
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
// If it is the first check point, initialize the rate index
uint256 previousCheckpoint = lastCheckpoint[_token];
if (lastCheckpoint[_token] == 0) {
if(cToken == address(0)) {
compoundPool[_token].supported = false;
borrowRateIndex[_token][blockNumber] = UNIT;
depositeRateIndex[_token][blockNumber] = UNIT;
// Update the last checkpoint
lastCheckpoint[_token] = blockNumber;
}
else {
compoundPool[_token].supported = true;
uint cTokenExchangeRate = ICToken(cToken).exchangeRateCurrent();
// Get the curretn cToken exchange rate in Compound, which is need to calculate DeFiner's rate
compoundPool[_token].capitalRatio = getCapitalCompoundRatio(_token);
compoundPool[_token].borrowRatePerBlock = ICToken(cToken).borrowRatePerBlock(); // initial value
compoundPool[_token].depositRatePerBlock = ICToken(cToken).supplyRatePerBlock(); // initial value
borrowRateIndex[_token][blockNumber] = UNIT;
depositeRateIndex[_token][blockNumber] = UNIT;
// Update the last checkpoint
lastCheckpoint[_token] = blockNumber;
lastCTokenExchangeRate[cToken] = cTokenExchangeRate;
}
} else {
if(cToken == address(0)) {
compoundPool[_token].supported = false;
borrowRateIndex[_token][blockNumber] = borrowRateIndexNow(_token);
depositeRateIndex[_token][blockNumber] = depositeRateIndexNow(_token);
// Update the last checkpoint
lastCheckpoint[_token] = blockNumber;
} else {
compoundPool[_token].supported = true;
uint cTokenExchangeRate = ICToken(cToken).exchangeRateCurrent();
// Get the curretn cToken exchange rate in Compound, which is need to calculate DeFiner's rate
compoundPool[_token].capitalRatio = getCapitalCompoundRatio(_token);
compoundPool[_token].borrowRatePerBlock = ICToken(cToken).borrowRatePerBlock();
compoundPool[_token].depositRatePerBlock = cTokenExchangeRate.mul(UNIT).div(lastCTokenExchangeRate[cToken])
.sub(UNIT).div(blockNumber.sub(lastCheckpoint[_token]));
borrowRateIndex[_token][blockNumber] = borrowRateIndexNow(_token);
depositeRateIndex[_token][blockNumber] = depositeRateIndexNow(_token);
// Update the last checkpoint
lastCheckpoint[_token] = blockNumber;
lastCTokenExchangeRate[cToken] = cTokenExchangeRate;
}
}
// Update the total loan
if(borrowRateIndex[_token][blockNumber] != UNIT) {
totalLoans[_token] = totalLoans[_token].mul(borrowRateIndex[_token][blockNumber])
.div(borrowRateIndex[_token][previousCheckpoint]);
}
emit UpdateIndex(_token, depositeRateIndex[_token][getBlockNumber()], borrowRateIndex[_token][getBlockNumber()]);
}
/**
* Calculate a token deposite rate of current block
* @param _token token address
* @dev This is an looking forward estimation from last checkpoint and not the exactly rate that the user will pay or earn.
*/
function depositeRateIndexNow(address _token) public view returns(uint) {
uint256 lcp = lastCheckpoint[_token];
// If this is the first checkpoint, set the index be 1.
if(lcp == 0)
return INT_UNIT;
uint256 lastDepositeRateIndex = depositeRateIndex[_token][lcp];
uint256 depositRatePerBlock = getDepositRatePerBlock(_token);
// newIndex = oldIndex*(1+r*delta_block). If delta_block = 0, i.e. the last checkpoint is current block, index doesn't change.
return lastDepositeRateIndex.mul(getBlockNumber().sub(lcp).mul(depositRatePerBlock).add(INT_UNIT)).div(INT_UNIT);
}
/**
* Calculate a token borrow rate of current block
* @param _token token address
*/
function borrowRateIndexNow(address _token) public view returns(uint) {
uint256 lcp = lastCheckpoint[_token];
// If this is the first checkpoint, set the index be 1.
if(lcp == 0)
return INT_UNIT;
uint256 lastBorrowRateIndex = borrowRateIndex[_token][lcp];
uint256 borrowRatePerBlock = getBorrowRatePerBlock(_token);
return lastBorrowRateIndex.mul(getBlockNumber().sub(lcp).mul(borrowRatePerBlock).add(INT_UNIT)).div(INT_UNIT);
}
/**
* Get the state of the given token
* @param _token token address
*/
function getTokenState(address _token) public view returns (uint256 deposits, uint256 loans, uint256 reserveBalance, uint256 remainingAssets){
return (
getTotalDepositStore(_token),
totalLoans[_token],
totalReserve[_token],
totalReserve[_token].add(totalCompound[globalConfig.tokenInfoRegistry().getCToken(_token)])
);
}
function getPoolAmount(address _token) public view returns(uint) {
return totalReserve[_token].add(totalCompound[globalConfig.tokenInfoRegistry().getCToken(_token)]);
}
function deposit(address _to, address _token, uint256 _amount) external onlyAuthorized {
require(_amount != 0, "Amount is zero");
// Add a new checkpoint on the index curve.
newRateIndexCheckpoint(_token);
updateDepositFINIndex(_token);
// Update tokenInfo. Add the _amount to principal, and update the last deposit block in tokenInfo
globalConfig.accounts().deposit(_to, _token, _amount);
// Update the amount of tokens in compound and loans, i.e. derive the new values
// of C (Compound Ratio) and U (Utilization Ratio).
uint compoundAmount = update(_token, _amount, ActionType.DepositAction);
if(compoundAmount > 0) {
globalConfig.savingAccount().toCompound(_token, compoundAmount);
}
}
function borrow(address _from, address _token, uint256 _amount) external onlyAuthorized {
// Add a new checkpoint on the index curve.
newRateIndexCheckpoint(_token);
updateBorrowFINIndex(_token);
// Update tokenInfo for the user
globalConfig.accounts().borrow(_from, _token, _amount);
// Update pool balance
// Update the amount of tokens in compound and loans, i.e. derive the new values
// of C (Compound Ratio) and U (Utilization Ratio).
uint compoundAmount = update(_token, _amount, ActionType.BorrowAction);
if(compoundAmount > 0) {
globalConfig.savingAccount().fromCompound(_token, compoundAmount);
}
}
function repay(address _to, address _token, uint256 _amount) external onlyAuthorized returns(uint) {
// Add a new checkpoint on the index curve.
newRateIndexCheckpoint(_token);
updateBorrowFINIndex(_token);
// Sanity check
require(globalConfig.accounts().getBorrowPrincipal(_to, _token) > 0,
"Token BorrowPrincipal must be greater than 0. To deposit balance, please use deposit button."
);
// Update tokenInfo
uint256 remain = globalConfig.accounts().repay(_to, _token, _amount);
// Update the amount of tokens in compound and loans, i.e. derive the new values
// of C (Compound Ratio) and U (Utilization Ratio).
uint compoundAmount = update(_token, _amount.sub(remain), ActionType.RepayAction);
if(compoundAmount > 0) {
globalConfig.savingAccount().toCompound(_token, compoundAmount);
}
// Return actual amount repaid
return _amount.sub(remain);
}
/**
* Withdraw a token from an address
* @param _from address to be withdrawn from
* @param _token token address
* @param _amount amount to be withdrawn
* @return The actually amount withdrawed, which will be the amount requested minus the commission fee.
*/
function withdraw(address _from, address _token, uint256 _amount) external onlyAuthorized returns(uint) {
require(_amount != 0, "Amount is zero");
// Add a new checkpoint on the index curve.
newRateIndexCheckpoint(_token);
updateDepositFINIndex(_token);
// Withdraw from the account
uint amount = globalConfig.accounts().withdraw(_from, _token, _amount);
// Update pool balance
// Update the amount of tokens in compound and loans, i.e. derive the new values
// of C (Compound Ratio) and U (Utilization Ratio).
uint compoundAmount = update(_token, amount, ActionType.WithdrawAction);
// Check if there are enough tokens in the pool.
if(compoundAmount > 0) {
globalConfig.savingAccount().fromCompound(_token, compoundAmount);
}
return amount;
}
/**
* Get current block number
* @return the current block number
*/
function getBlockNumber() private view returns (uint) {
return block.number;
}
function version() public pure returns(string memory) {
return "v1.2.0";
}
} | Update the token principla and interest | function borrow(address _accountAddr, address _token, uint256 _amount) external onlyAuthorized {
initCollateralFlag(_accountAddr);
require(_amount != 0, "borrow amount is 0");
require(isUserHasAnyDeposits(_accountAddr), "no user deposits");
(uint8 tokenIndex, uint256 tokenDivisor, uint256 tokenPrice,) = globalConfig.tokenInfoRegistry().getTokenInfoFromAddress(_token);
require(
getBorrowETH(_accountAddr).add(_amount.mul(tokenPrice).div(tokenDivisor)) <=
getBorrowPower(_accountAddr), "Insufficient collateral when borrow"
);
AccountTokenLib.TokenInfo storage tokenInfo = accounts[_accountAddr].tokenInfos[_token];
uint256 blockNumber = getBlockNumber();
uint256 lastBorrowBlock = tokenInfo.getLastBorrowBlock();
if(lastBorrowBlock == 0)
tokenInfo.borrow(_amount, INT_UNIT, blockNumber);
else {
calculateBorrowFIN(lastBorrowBlock, _token, _accountAddr, blockNumber);
uint256 accruedRate = globalConfig.bank().getBorrowAccruedRate(_token, lastBorrowBlock);
tokenInfo.borrow(_amount, accruedRate, blockNumber);
}
}
| 5,774,190 | [
1,
1891,
326,
1147,
846,
267,
8450,
412,
69,
471,
16513,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
29759,
12,
2867,
389,
4631,
3178,
16,
1758,
389,
2316,
16,
2254,
5034,
389,
8949,
13,
3903,
1338,
15341,
288,
203,
3639,
1208,
13535,
2045,
287,
4678,
24899,
4631,
3178,
1769,
203,
3639,
2583,
24899,
8949,
480,
374,
16,
315,
70,
15318,
3844,
353,
374,
8863,
203,
3639,
2583,
12,
291,
1299,
5582,
2961,
758,
917,
1282,
24899,
4631,
3178,
3631,
315,
2135,
729,
443,
917,
1282,
8863,
203,
3639,
261,
11890,
28,
1147,
1016,
16,
2254,
5034,
1147,
7244,
12385,
16,
2254,
5034,
1147,
5147,
16,
13,
273,
2552,
809,
18,
2316,
966,
4243,
7675,
588,
1345,
966,
1265,
1887,
24899,
2316,
1769,
203,
3639,
2583,
12,
203,
5411,
2882,
15318,
1584,
44,
24899,
4631,
3178,
2934,
1289,
24899,
8949,
18,
16411,
12,
2316,
5147,
2934,
2892,
12,
2316,
7244,
12385,
3719,
1648,
203,
5411,
2882,
15318,
13788,
24899,
4631,
3178,
3631,
315,
5048,
11339,
4508,
2045,
287,
1347,
29759,
6,
203,
3639,
11272,
203,
203,
3639,
6590,
1345,
5664,
18,
1345,
966,
2502,
1147,
966,
273,
9484,
63,
67,
4631,
3178,
8009,
2316,
7655,
63,
67,
2316,
15533,
203,
3639,
2254,
5034,
1203,
1854,
273,
11902,
1854,
5621,
203,
3639,
2254,
5034,
1142,
38,
15318,
1768,
273,
1147,
966,
18,
588,
3024,
38,
15318,
1768,
5621,
203,
203,
3639,
309,
12,
2722,
38,
15318,
1768,
422,
374,
13,
203,
5411,
1147,
966,
18,
70,
15318,
24899,
8949,
16,
6137,
67,
15736,
16,
1203,
1854,
1769,
203,
3639,
469,
288,
203,
5411,
4604,
38,
15318,
7263,
12,
2722,
38,
15318,
1768,
2
]
|
pragma solidity 0.6.6;
import "../../node_modules/@openzeppelin/contracts/GSN/IRelayRecipient.sol";
// copied here to be included in coverage
/**
* @dev Base GSN recipient contract: includes the {IRelayRecipient} interface
* and enables GSN support on all contracts in the inheritance tree.
*
* TIP: This contract is abstract. The functions {IRelayRecipient-acceptRelayedCall},
* {_preRelayedCall}, and {_postRelayedCall} are not implemented and must be
* provided by derived contracts. See the
* xref:ROOT:gsn-strategies.adoc#gsn-strategies[GSN strategies] for more
* information on how to use the pre-built {GSNRecipientSignature} and
* {GSNRecipientERC20Fee}, or how to write your own.
*/
contract GSNModule is IRelayRecipient {
uint256 private constant _RELAYED_CALL_ACCEPTED = 0;
uint256 private constant _RELAYED_CALL_REJECTED = 11;
function getHubAddr() external override view returns (address) {
// this is not needed nor used
// only implemented to statisfy IRelayRecipient
return address(0);
}
function acceptRelayedCall(
address, /* relay */
address, /* from */
bytes calldata, /* encodedFunction */
uint256, /* transactionFee */
uint256, /* gasPrice */
uint256, /* gasLimit */
uint256, /* nonce */
bytes calldata, /* approvalData */
uint256 /* maxPossibleCharge */
) external override view returns (uint256, bytes memory) {
_approveRelayedCall();
}
// Base implementations for pre and post relayedCall: only RelayHub can invoke them, and data is forwarded to the
// internal hook.
/**
* @dev See `IRelayRecipient.preRelayedCall`.
*
* This function should not be overriden directly, use `_preRelayedCall` instead.
*
* * Requirements:
*
* - the caller must be the `RelayHub` contract.
*/
function preRelayedCall(
bytes memory /* context */
) public virtual override returns (bytes32) {
return "";
}
/**
* @dev See `IRelayRecipient.postRelayedCall`.
*
* This function should not be overriden directly, use `_postRelayedCall` instead.
*
* * Requirements:
*
* - the caller must be the `RelayHub` contract.
*/
function postRelayedCall(
bytes memory, /* context */
bool, /* success */
uint256, /* actualCharge */
bytes32 /* preRetVal */
) public virtual override {
this;
}
/**
* @dev Return this in acceptRelayedCall to proceed with the execution of a relayed call. Note that this contract
* will be charged a fee by RelayHub
*/
function _approveRelayedCall()
internal
pure
returns (uint256, bytes memory)
{
return _approveRelayedCall("");
}
/**
* @dev See `GSNRecipient._approveRelayedCall`.
*
* This overload forwards `context` to _preRelayedCall and _postRelayedCall.
*/
function _approveRelayedCall(bytes memory context)
internal
pure
returns (uint256, bytes memory)
{
return (_RELAYED_CALL_ACCEPTED, context);
}
/**
* @dev 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, "");
}
}
| * @dev 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, "");
}
| 7,226,139 | [
1,
990,
333,
316,
2791,
27186,
329,
1477,
358,
709,
347,
323,
4588,
434,
279,
18874,
329,
745,
18,
2631,
1656,
281,
903,
506,
1149,
2423,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
202,
915,
389,
24163,
27186,
329,
1477,
12,
11890,
5034,
12079,
13,
203,
202,
202,
7236,
203,
202,
202,
84,
594,
203,
202,
202,
6154,
261,
11890,
5034,
16,
1731,
3778,
13,
203,
202,
95,
203,
202,
202,
2463,
261,
67,
862,
7868,
2056,
67,
13730,
67,
862,
5304,
2056,
397,
12079,
16,
1408,
1769,
203,
202,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0x95d90E8e8A05F4125e84018B685E95484fAB8152/sources/contracts/NativeRouter.sol | @inheritdoc INativeRouter the outputs of prior swaps become the inputs to subsequent ones decide whether to continue or terminate | function exactInput(
ExactInputParams memory params
) external payable override nonReentrant returns (uint256 amountOut) {
require(
verifyWidgetFeeSignature(params.widgetFee, params.widgetFeeSignature),
"widget fee signature is invalid"
);
require(params.widgetFee.feeRate <= 10000, "invalid widget fee");
bool hasAlreadyPaid;
(Orders.Order memory order, ) = params.orders.decodeFirstOrder();
if (params.amountIn == 0) {
hasAlreadyPaid = true;
params.amountIn = IERC20(order.sellerToken).balanceOf(address(this));
}
require(order.seller == msg.sender, "seller is not correct");
address payer = hasAlreadyPaid ? address(this) : msg.sender;
uint widgetFeeAmount = (params.amountIn * params.widgetFee.feeRate) /
TEN_THOUSAND_DENOMINATOR;
TransferHelper.safeTransferFrom(
order.sellerToken,
msg.sender,
params.widgetFee.feeRecipient,
widgetFeeAmount
);
emit WidgetFeeTransfer(
params.widgetFee.feeRecipient,
params.widgetFee.feeRate,
widgetFeeAmount
);
params.amountIn -= widgetFeeAmount;
while (true) {
bool hasMultiplePools = params.orders.hasMultiplePools();
params.amountIn = exactInputInternal(
params.amountIn,
hasMultiplePools ? address(this) : params.recipient,
SwapCallbackData({
payer: payer
})
);
if (hasMultiplePools) {
payer = address(this);
params.orders = params.orders.skipOrder();
amountOut = params.amountIn;
break;
}
}
require(amountOut >= params.amountOutMinimum, "Too little received");
if (address(this).balance > 0)
TransferHelper.safeTransferETH(msg.sender, address(this).balance);
}
| 4,997,266 | [
1,
36,
10093,
2120,
1535,
8259,
326,
6729,
434,
6432,
1352,
6679,
12561,
326,
4540,
358,
10815,
5945,
16288,
2856,
358,
1324,
578,
10850,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
5565,
1210,
12,
203,
3639,
30794,
1210,
1370,
3778,
859,
203,
565,
262,
3903,
8843,
429,
3849,
1661,
426,
8230,
970,
1135,
261,
11890,
5034,
3844,
1182,
13,
288,
203,
3639,
2583,
12,
203,
5411,
3929,
4609,
14667,
5374,
12,
2010,
18,
6587,
14667,
16,
859,
18,
6587,
14667,
5374,
3631,
203,
5411,
315,
6587,
14036,
3372,
353,
2057,
6,
203,
3639,
11272,
203,
3639,
2583,
12,
2010,
18,
6587,
14667,
18,
21386,
4727,
1648,
12619,
16,
315,
5387,
3604,
14036,
8863,
203,
3639,
1426,
711,
9430,
16507,
350,
31,
203,
3639,
261,
16528,
18,
2448,
3778,
1353,
16,
262,
273,
859,
18,
9972,
18,
3922,
3759,
2448,
5621,
203,
3639,
309,
261,
2010,
18,
8949,
382,
422,
374,
13,
288,
203,
5411,
711,
9430,
16507,
350,
273,
638,
31,
203,
5411,
859,
18,
8949,
382,
273,
467,
654,
39,
3462,
12,
1019,
18,
1786,
749,
1345,
2934,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
3639,
289,
203,
3639,
2583,
12,
1019,
18,
1786,
749,
422,
1234,
18,
15330,
16,
315,
1786,
749,
353,
486,
3434,
8863,
203,
203,
3639,
1758,
293,
1773,
273,
711,
9430,
16507,
350,
692,
1758,
12,
2211,
13,
294,
1234,
18,
15330,
31,
203,
203,
3639,
2254,
3604,
14667,
6275,
273,
261,
2010,
18,
8949,
382,
380,
859,
18,
6587,
14667,
18,
21386,
4727,
13,
342,
203,
5411,
399,
1157,
67,
2455,
21667,
4307,
67,
13296,
1872,
706,
3575,
31,
203,
3639,
12279,
2276,
18,
4626,
5912,
1265,
12,
203,
5411,
1353,
18,
1786,
749,
1345,
2
]
|
./full_match/137/0xcf501EaD3EbfA60f40725fcA1D82Fc05bfF63Bf2/sources/CDHInventory.sol | @notice Get detailed information of the tokenId, including its name, type, rarity, rank, level and uri to token. @dev Card information is returned from the pool based on where token is created. @param id Token Id for which card details is to be retrieved. @return name (Card Name), cardType(Card Type), rarity, Rank, Level, _uri(card urls) and blockNum. | function info(uint256 id) external view returns (string memory name, bytes16 cardType, bytes1 rarity, uint256 rank, uint256 level, string memory _uri, uint256 blockNum) {
uint256 cardId = card(id);
CardPool _pool = CardPool(tokenPools[id]);
(name, cardType, rarity, rank, level, _uri) = _pool.getCard(cardId);
blockNum = blockNumber[id];
}
| 4,748,319 | [
1,
967,
6864,
1779,
434,
326,
1147,
548,
16,
6508,
2097,
508,
16,
618,
16,
436,
20498,
16,
6171,
16,
1801,
471,
2003,
358,
1147,
18,
225,
14338,
1779,
353,
2106,
628,
326,
2845,
2511,
603,
1625,
1147,
353,
2522,
18,
225,
612,
3155,
3124,
364,
1492,
5270,
3189,
353,
358,
506,
10295,
18,
327,
508,
261,
6415,
1770,
3631,
5270,
559,
12,
6415,
1412,
3631,
436,
20498,
16,
534,
2304,
16,
4557,
16,
389,
1650,
12,
3327,
6903,
13,
471,
1203,
2578,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
1123,
12,
11890,
5034,
612,
13,
3903,
1476,
1135,
261,
1080,
3778,
508,
16,
1731,
2313,
5270,
559,
16,
1731,
21,
436,
20498,
16,
2254,
5034,
6171,
16,
2254,
5034,
1801,
16,
533,
3778,
389,
1650,
16,
2254,
5034,
1203,
2578,
13,
288,
203,
3639,
2254,
5034,
5270,
548,
273,
5270,
12,
350,
1769,
203,
3639,
14338,
2864,
389,
6011,
273,
14338,
2864,
12,
2316,
16639,
63,
350,
19226,
203,
3639,
261,
529,
16,
5270,
559,
16,
436,
20498,
16,
6171,
16,
1801,
16,
389,
1650,
13,
273,
389,
6011,
18,
588,
6415,
12,
3327,
548,
1769,
203,
203,
3639,
1203,
2578,
273,
1203,
1854,
63,
350,
15533,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0xDEf136D9884528e1EB302f39457af0E4d3AD24EB/sources/LimitOrders.sol | ============ Constants ============ EIP191 header for EIP712 prefix EIP712 Domain Name value EIP712 Domain Version value Hash of the EIP712 Domain Separator Schema Hash of the EIP712 LimitOrder struct Number of bytes in an Order struct Number of bytes in a typed signature Number of bytes in a CallFunctionData struct ============ Enums ============ | {
using Math for uint256;
using SafeMath for uint256;
using Types for Types.Par;
using Types for Types.Wei;
bytes32 constant private FILE = "LimitOrders";
bytes2 constant private EIP191_HEADER = 0x1901;
string constant private EIP712_DOMAIN_NAME = "LimitOrders";
string constant private EIP712_DOMAIN_VERSION = "1.1";
bytes32 constant private EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256(abi.encodePacked(
"EIP712Domain(",
"string name,",
"string version,",
"uint256 chainId,",
"address verifyingContract",
")"
));
bytes32 constant private EIP712_LIMIT_ORDER_STRUCT_SCHEMA_HASH = keccak256(abi.encodePacked(
"LimitOrder(",
"uint256 makerMarket,",
"uint256 takerMarket,",
"uint256 makerAmount,",
"uint256 takerAmount,",
"address makerAccountOwner,",
"uint256 makerAccountNumber,",
"address takerAccountOwner,",
"uint256 takerAccountNumber,",
"uint256 expiration,",
"uint256 salt",
")"
));
uint256 constant private NUM_ORDER_BYTES = 320;
uint256 constant private NUM_SIGNATURE_BYTES = 66;
uint256 constant private NUM_CALLFUNCTIONDATA_BYTES = 32 + NUM_ORDER_BYTES;
contract LimitOrders is
enum OrderStatus {
Null,
Approved,
Canceled
}
enum CallFunctionType {
Approve,
Cancel
}
struct Order {
uint256 makerMarket;
uint256 takerMarket;
uint256 makerAmount;
uint256 takerAmount;
address makerAccountOwner;
uint256 makerAccountNumber;
address takerAccountOwner;
uint256 takerAccountNumber;
uint256 expiration;
uint256 salt;
}
struct OrderInfo {
Order order;
bytes32 orderHash;
}
struct CallFunctionData {
CallFunctionType callType;
Order order;
}
struct OrderQueryOutput {
OrderStatus orderStatus;
uint256 orderMakerFilledAmount;
}
event ContractStatusSet(
bool operational
);
event LogLimitOrderCanceled(
bytes32 indexed orderHash,
address indexed canceler,
uint256 makerMarket,
uint256 takerMarket
);
event LogLimitOrderApproved(
bytes32 indexed orderHash,
address indexed approver,
uint256 makerMarket,
uint256 takerMarket
);
event LogLimitOrderFilled(
bytes32 indexed orderHash,
address indexed orderMaker,
uint256 makerFillAmount,
uint256 totalMakerFilledAmount
);
constructor (
address soloMargin,
uint256 chainId
)
public
OnlySolo(soloMargin)
bytes32 public EIP712_DOMAIN_HASH;
bool public g_isOperational;
mapping (bytes32 => uint256) public g_makerFilledAmount;
mapping (bytes32 => OrderStatus) public g_status;
{
g_isOperational = true;
EIP712_DOMAIN_HASH = keccak256(abi.encode(
EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
keccak256(bytes(EIP712_DOMAIN_NAME)),
keccak256(bytes(EIP712_DOMAIN_VERSION)),
chainId,
address(this)
));
}
function shutDown()
external
onlyOwner
{
g_isOperational = false;
emit ContractStatusSet(false);
}
function startUp()
external
onlyOwner
{
g_isOperational = true;
emit ContractStatusSet(true);
}
function cancelOrder(
Order memory order
)
public
{
cancelOrderInternal(msg.sender, order);
}
function approveOrder(
Order memory order
)
public
{
approveOrderInternal(msg.sender, order);
}
function getTradeCost(
uint256 inputMarketId,
uint256 outputMarketId,
Account.Info memory makerAccount,
Account.Info memory takerAccount,
Types.Par memory /* oldInputPar */,
Types.Par memory /* newInputPar */,
Types.Wei memory inputWei,
bytes memory data
)
public
onlySolo(msg.sender)
returns (Types.AssetAmount memory)
{
Require.that(
g_isOperational,
FILE,
"Contract is not operational"
);
OrderInfo memory orderInfo = getOrderAndValidateSignature(data);
verifyOrderAndAccountsAndMarkets(
orderInfo,
makerAccount,
takerAccount,
inputMarketId,
outputMarketId,
inputWei
);
return getOutputAssetAmount(
inputMarketId,
outputMarketId,
inputWei,
orderInfo
);
}
function callFunction(
address /* sender */,
Account.Info memory accountInfo,
bytes memory data
)
public
onlySolo(msg.sender)
{
Require.that(
data.length == NUM_CALLFUNCTIONDATA_BYTES,
FILE,
"Cannot parse CallFunctionData"
);
CallFunctionData memory cfd = abi.decode(data, (CallFunctionData));
if (cfd.callType == CallFunctionType.Approve) {
approveOrderInternal(accountInfo.owner, cfd.order);
assert(cfd.callType == CallFunctionType.Cancel);
cancelOrderInternal(accountInfo.owner, cfd.order);
}
}
function callFunction(
address /* sender */,
Account.Info memory accountInfo,
bytes memory data
)
public
onlySolo(msg.sender)
{
Require.that(
data.length == NUM_CALLFUNCTIONDATA_BYTES,
FILE,
"Cannot parse CallFunctionData"
);
CallFunctionData memory cfd = abi.decode(data, (CallFunctionData));
if (cfd.callType == CallFunctionType.Approve) {
approveOrderInternal(accountInfo.owner, cfd.order);
assert(cfd.callType == CallFunctionType.Cancel);
cancelOrderInternal(accountInfo.owner, cfd.order);
}
}
} else {
function getOrderStates(
bytes32[] memory orderHashes
)
public
view
returns(OrderQueryOutput[] memory)
{
uint256 numOrders = orderHashes.length;
OrderQueryOutput[] memory output = new OrderQueryOutput[](numOrders);
for (uint256 i = 0; i < numOrders; i++) {
bytes32 orderHash = orderHashes[i];
output[i] = OrderQueryOutput({
orderStatus: g_status[orderHash],
orderMakerFilledAmount: g_makerFilledAmount[orderHash]
});
}
return output;
}
function getOrderStates(
bytes32[] memory orderHashes
)
public
view
returns(OrderQueryOutput[] memory)
{
uint256 numOrders = orderHashes.length;
OrderQueryOutput[] memory output = new OrderQueryOutput[](numOrders);
for (uint256 i = 0; i < numOrders; i++) {
bytes32 orderHash = orderHashes[i];
output[i] = OrderQueryOutput({
orderStatus: g_status[orderHash],
orderMakerFilledAmount: g_makerFilledAmount[orderHash]
});
}
return output;
}
function getOrderStates(
bytes32[] memory orderHashes
)
public
view
returns(OrderQueryOutput[] memory)
{
uint256 numOrders = orderHashes.length;
OrderQueryOutput[] memory output = new OrderQueryOutput[](numOrders);
for (uint256 i = 0; i < numOrders; i++) {
bytes32 orderHash = orderHashes[i];
output[i] = OrderQueryOutput({
orderStatus: g_status[orderHash],
orderMakerFilledAmount: g_makerFilledAmount[orderHash]
});
}
return output;
}
function cancelOrderInternal(
address canceler,
Order memory order
)
private
{
Require.that(
canceler == order.makerAccountOwner,
FILE,
"Canceler must be maker"
);
bytes32 orderHash = getOrderHash(order);
g_status[orderHash] = OrderStatus.Canceled;
emit LogLimitOrderCanceled(
orderHash,
canceler,
order.makerMarket,
order.takerMarket
);
}
function approveOrderInternal(
address approver,
Order memory order
)
private
{
Require.that(
approver == order.makerAccountOwner,
FILE,
"Approver must be maker"
);
bytes32 orderHash = getOrderHash(order);
Require.that(
g_status[orderHash] != OrderStatus.Canceled,
FILE,
"Cannot approve canceled order",
orderHash
);
g_status[orderHash] = OrderStatus.Approved;
emit LogLimitOrderApproved(
orderHash,
approver,
order.makerMarket,
order.takerMarket
);
}
function verifyOrderAndAccountsAndMarkets(
OrderInfo memory orderInfo,
Account.Info memory makerAccount,
Account.Info memory takerAccount,
uint256 inputMarketId,
uint256 outputMarketId,
Types.Wei memory inputWei
)
private
view
{
Require.that(
orderInfo.order.expiration == 0 || orderInfo.order.expiration >= block.timestamp,
FILE,
"Order expired",
orderInfo.orderHash
);
Require.that(
makerAccount.owner == orderInfo.order.makerAccountOwner &&
makerAccount.number == orderInfo.order.makerAccountNumber,
FILE,
"Order maker account mismatch",
orderInfo.orderHash
);
Require.that(
(
orderInfo.order.takerAccountOwner == address(0) &&
orderInfo.order.takerAccountNumber == 0
) || (
orderInfo.order.takerAccountOwner == takerAccount.owner &&
orderInfo.order.takerAccountNumber == takerAccount.number
),
FILE,
"Order taker account mismatch",
orderInfo.orderHash
);
Require.that(
(
orderInfo.order.makerMarket == outputMarketId &&
orderInfo.order.takerMarket == inputMarketId
) || (
orderInfo.order.takerMarket == outputMarketId &&
orderInfo.order.makerMarket == inputMarketId
),
FILE,
"Market mismatch",
orderInfo.orderHash
);
Require.that(
!inputWei.isZero(),
FILE,
"InputWei is zero",
orderInfo.orderHash
);
Require.that(
inputWei.sign == (orderInfo.order.takerMarket == inputMarketId),
FILE,
"InputWei sign mismatch",
orderInfo.orderHash
);
}
function getOutputAssetAmount(
uint256 inputMarketId,
uint256 outputMarketId,
Types.Wei memory inputWei,
OrderInfo memory orderInfo
)
private
returns (Types.AssetAmount memory)
{
uint256 outputAmount;
uint256 makerFillAmount;
if (orderInfo.order.takerMarket == inputMarketId) {
outputAmount = inputWei.value.getPartial(
orderInfo.order.makerAmount,
orderInfo.order.takerAmount
);
makerFillAmount = outputAmount;
assert(orderInfo.order.takerMarket == outputMarketId);
outputAmount = inputWei.value.getPartialRoundUp(
orderInfo.order.takerAmount,
orderInfo.order.makerAmount
);
makerFillAmount = inputWei.value;
}
updateMakerFilledAmount(orderInfo, makerFillAmount);
return Types.AssetAmount({
sign: orderInfo.order.takerMarket == outputMarketId,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: outputAmount
});
}
function getOutputAssetAmount(
uint256 inputMarketId,
uint256 outputMarketId,
Types.Wei memory inputWei,
OrderInfo memory orderInfo
)
private
returns (Types.AssetAmount memory)
{
uint256 outputAmount;
uint256 makerFillAmount;
if (orderInfo.order.takerMarket == inputMarketId) {
outputAmount = inputWei.value.getPartial(
orderInfo.order.makerAmount,
orderInfo.order.takerAmount
);
makerFillAmount = outputAmount;
assert(orderInfo.order.takerMarket == outputMarketId);
outputAmount = inputWei.value.getPartialRoundUp(
orderInfo.order.takerAmount,
orderInfo.order.makerAmount
);
makerFillAmount = inputWei.value;
}
updateMakerFilledAmount(orderInfo, makerFillAmount);
return Types.AssetAmount({
sign: orderInfo.order.takerMarket == outputMarketId,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: outputAmount
});
}
} else {
function getOutputAssetAmount(
uint256 inputMarketId,
uint256 outputMarketId,
Types.Wei memory inputWei,
OrderInfo memory orderInfo
)
private
returns (Types.AssetAmount memory)
{
uint256 outputAmount;
uint256 makerFillAmount;
if (orderInfo.order.takerMarket == inputMarketId) {
outputAmount = inputWei.value.getPartial(
orderInfo.order.makerAmount,
orderInfo.order.takerAmount
);
makerFillAmount = outputAmount;
assert(orderInfo.order.takerMarket == outputMarketId);
outputAmount = inputWei.value.getPartialRoundUp(
orderInfo.order.takerAmount,
orderInfo.order.makerAmount
);
makerFillAmount = inputWei.value;
}
updateMakerFilledAmount(orderInfo, makerFillAmount);
return Types.AssetAmount({
sign: orderInfo.order.takerMarket == outputMarketId,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: outputAmount
});
}
function updateMakerFilledAmount(
OrderInfo memory orderInfo,
uint256 makerFillAmount
)
private
{
uint256 oldMakerFilledAmount = g_makerFilledAmount[orderInfo.orderHash];
uint256 totalMakerFilledAmount = oldMakerFilledAmount.add(makerFillAmount);
Require.that(
totalMakerFilledAmount <= orderInfo.order.makerAmount,
FILE,
"Cannot overfill order",
orderInfo.orderHash,
oldMakerFilledAmount,
makerFillAmount
);
g_makerFilledAmount[orderInfo.orderHash] = totalMakerFilledAmount;
emit LogLimitOrderFilled(
orderInfo.orderHash,
orderInfo.order.makerAccountOwner,
makerFillAmount,
totalMakerFilledAmount
);
}
function getOrderAndValidateSignature(
bytes memory data
)
private
view
returns (OrderInfo memory)
{
Require.that(
(
data.length == NUM_ORDER_BYTES ||
data.length == NUM_ORDER_BYTES + NUM_SIGNATURE_BYTES
),
FILE,
"Cannot parse order from data"
);
OrderInfo memory orderInfo;
orderInfo.order = abi.decode(data, (Order));
orderInfo.orderHash = getOrderHash(orderInfo.order);
OrderStatus orderStatus = g_status[orderInfo.orderHash];
if (orderStatus == OrderStatus.Null) {
bytes memory signature = parseSignature(data);
address signer = TypedSignature.recover(orderInfo.orderHash, signature);
Require.that(
orderInfo.order.makerAccountOwner == signer,
FILE,
"Order invalid signature",
orderInfo.orderHash
);
Require.that(
orderStatus != OrderStatus.Canceled,
FILE,
"Order canceled",
orderInfo.orderHash
);
assert(orderStatus == OrderStatus.Approved);
}
return orderInfo;
}
function getOrderAndValidateSignature(
bytes memory data
)
private
view
returns (OrderInfo memory)
{
Require.that(
(
data.length == NUM_ORDER_BYTES ||
data.length == NUM_ORDER_BYTES + NUM_SIGNATURE_BYTES
),
FILE,
"Cannot parse order from data"
);
OrderInfo memory orderInfo;
orderInfo.order = abi.decode(data, (Order));
orderInfo.orderHash = getOrderHash(orderInfo.order);
OrderStatus orderStatus = g_status[orderInfo.orderHash];
if (orderStatus == OrderStatus.Null) {
bytes memory signature = parseSignature(data);
address signer = TypedSignature.recover(orderInfo.orderHash, signature);
Require.that(
orderInfo.order.makerAccountOwner == signer,
FILE,
"Order invalid signature",
orderInfo.orderHash
);
Require.that(
orderStatus != OrderStatus.Canceled,
FILE,
"Order canceled",
orderInfo.orderHash
);
assert(orderStatus == OrderStatus.Approved);
}
return orderInfo;
}
} else {
function getOrderHash(
Order memory order
)
private
view
returns (bytes32)
{
bytes32 structHash = keccak256(abi.encode(
EIP712_LIMIT_ORDER_STRUCT_SCHEMA_HASH,
order
));
return keccak256(abi.encodePacked(
EIP191_HEADER,
EIP712_DOMAIN_HASH,
structHash
));
}
function parseSignature(
bytes memory data
)
private
pure
returns (bytes memory)
{
Require.that(
data.length == NUM_ORDER_BYTES + NUM_SIGNATURE_BYTES,
FILE,
"Cannot parse signature from data"
);
bytes memory signature = new bytes(NUM_SIGNATURE_BYTES);
uint256 sigOffset = NUM_ORDER_BYTES;
assembly {
let sigStart := add(data, sigOffset)
mstore(add(signature, 0x020), mload(add(sigStart, 0x20)))
mstore(add(signature, 0x040), mload(add(sigStart, 0x40)))
mstore(add(signature, 0x042), mload(add(sigStart, 0x42)))
}
return signature;
}
function parseSignature(
bytes memory data
)
private
pure
returns (bytes memory)
{
Require.that(
data.length == NUM_ORDER_BYTES + NUM_SIGNATURE_BYTES,
FILE,
"Cannot parse signature from data"
);
bytes memory signature = new bytes(NUM_SIGNATURE_BYTES);
uint256 sigOffset = NUM_ORDER_BYTES;
assembly {
let sigStart := add(data, sigOffset)
mstore(add(signature, 0x020), mload(add(sigStart, 0x20)))
mstore(add(signature, 0x040), mload(add(sigStart, 0x40)))
mstore(add(signature, 0x042), mload(add(sigStart, 0x42)))
}
return signature;
}
} | 15,486,151 | [
1,
14468,
5245,
422,
1432,
631,
512,
2579,
30380,
1446,
364,
512,
2579,
27,
2138,
1633,
512,
2579,
27,
2138,
6648,
1770,
460,
512,
2579,
27,
2138,
6648,
4049,
460,
2474,
434,
326,
512,
2579,
27,
2138,
6648,
27519,
4611,
2474,
434,
326,
512,
2579,
27,
2138,
7214,
2448,
1958,
3588,
434,
1731,
316,
392,
4347,
1958,
3588,
434,
1731,
316,
279,
9092,
3372,
3588,
434,
1731,
316,
279,
3049,
2083,
751,
1958,
422,
1432,
631,
6057,
87,
422,
1432,
631,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
95,
203,
565,
1450,
2361,
364,
2254,
5034,
31,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
565,
1450,
7658,
364,
7658,
18,
1553,
31,
203,
565,
1450,
7658,
364,
7658,
18,
3218,
77,
31,
203,
203,
203,
565,
1731,
1578,
5381,
3238,
7527,
273,
315,
3039,
16528,
14432,
203,
203,
565,
1731,
22,
5381,
3238,
512,
2579,
30380,
67,
7557,
273,
374,
92,
3657,
1611,
31,
203,
203,
565,
533,
5381,
3238,
512,
2579,
27,
2138,
67,
18192,
67,
1985,
273,
315,
3039,
16528,
14432,
203,
203,
565,
533,
5381,
3238,
512,
2579,
27,
2138,
67,
18192,
67,
5757,
273,
315,
21,
18,
21,
14432,
203,
203,
565,
1731,
1578,
5381,
3238,
512,
2579,
27,
2138,
67,
18192,
67,
4550,
67,
14233,
67,
15920,
273,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
203,
3639,
315,
41,
2579,
27,
2138,
3748,
2932,
16,
203,
3639,
315,
1080,
508,
16,
3113,
203,
3639,
315,
1080,
1177,
16,
3113,
203,
3639,
315,
11890,
5034,
2687,
548,
16,
3113,
203,
3639,
315,
2867,
3929,
310,
8924,
3113,
203,
3639,
7310,
203,
565,
262,
1769,
203,
203,
565,
1731,
1578,
5381,
3238,
512,
2579,
27,
2138,
67,
8283,
67,
7954,
67,
13915,
67,
14233,
67,
15920,
273,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
203,
3639,
315,
3039,
2448,
2932,
16,
203,
3639,
315,
11890,
5034,
312,
6388,
3882,
278,
16,
3113,
203,
3639,
315,
11890,
5034,
268,
6388,
3882,
278,
16,
3113,
203,
3639,
315,
11890,
5034,
2
]
|
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.8;
/**
* @title LendToAaveMigrator
* @notice This contract implements the migration from LEND to AAVE token
* @author Aave
*/
interface ILendToAaveMigrator {
function LEND() external view returns(address);
/**
* @dev executes the migration from LEND to AAVE. Users need to give allowance to this contract to transfer LEND before executing
* this transaction.
* @param amount the amount of LEND to be migrated
*/
function migrateFromLEND(uint256 amount) external;
} | * @title LendToAaveMigrator @notice This contract implements the migration from LEND to AAVE token @author Aave/ | interface ILendToAaveMigrator {
function LEND() external view returns(address);
function migrateFromLEND(uint256 amount) external;
pragma solidity ^0.6.8;
} | 12,960,638 | [
1,
48,
409,
774,
37,
836,
25483,
639,
225,
1220,
6835,
4792,
326,
6333,
628,
511,
4415,
358,
432,
26714,
1147,
225,
432,
836,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
5831,
467,
48,
409,
774,
37,
836,
25483,
639,
288,
203,
565,
445,
511,
4415,
1435,
3903,
1476,
1135,
12,
2867,
1769,
203,
565,
445,
13187,
1265,
900,
2908,
12,
11890,
5034,
3844,
13,
3903,
31,
203,
683,
9454,
18035,
560,
3602,
20,
18,
26,
18,
28,
31,
203,
97,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/56/0x85CB9f16d09a640356aEC7B0B06ebBD416129493/sources/MasterChef.sol | NOOM1 tokens created per block. | uint256 public noom1PerBlock;
| 11,152,232 | [
1,
3417,
1872,
21,
2430,
2522,
1534,
1203,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
2254,
5034,
1071,
1158,
362,
21,
2173,
1768,
31,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// Сочетаемость глаголов (и отглагольных частей речи) с предложным
// паттерном.
// LC->07.08.2018
facts гл_предл language=Russian
{
arity=3
//violation_score=-5
generic
return=boolean
}
#define ГЛ_ИНФ(v) инфинитив:v{}, глагол:v{}
#region Предлог_В
// ------------------- С ПРЕДЛОГОМ 'В' ---------------------------
#region Предложный
// Глаголы и отглагольные части речи, присоединяющие
// предложное дополнение с предлогом В и сущ. в предложном падеже.
wordentry_set Гл_В_Предл =
{
rus_verbs:взорваться{}, // В Дагестане взорвался автомобиль
// вернуть после перекомпиляции rus_verbs:подорожать{}, // В Дагестане подорожал хлеб
rus_verbs:воевать{}, // Воевал во Франции.
rus_verbs:устать{}, // Устали в дороге?
rus_verbs:изнывать{}, // В Лондоне Черчилль изнывал от нетерпения.
rus_verbs:решить{}, // Что решат в правительстве?
rus_verbs:выскакивать{}, // Один из бойцов на улицу выскакивает.
rus_verbs:обстоять{}, // В действительности же дело обстояло не так.
rus_verbs:подыматься{},
rus_verbs:поехать{}, // поедем в такси!
rus_verbs:уехать{}, // он уехал в такси
rus_verbs:прибыть{}, // они прибыли в качестве независимых наблюдателей
rus_verbs:ОБЛАЧИТЬ{},
rus_verbs:ОБЛАЧАТЬ{},
rus_verbs:ОБЛАЧИТЬСЯ{},
rus_verbs:ОБЛАЧАТЬСЯ{},
rus_verbs:НАРЯДИТЬСЯ{},
rus_verbs:НАРЯЖАТЬСЯ{},
rus_verbs:ПОВАЛЯТЬСЯ{}, // повалявшись в снегу, бежать обратно в тепло.
rus_verbs:ПОКРЫВАТЬ{}, // Во многих местах ее покрывали трещины, наросты и довольно плоские выступы. (ПОКРЫВАТЬ)
rus_verbs:ПРОЖИГАТЬ{}, // Синий луч искрился белыми пятнами и прожигал в земле дымящуюся борозду. (ПРОЖИГАТЬ)
rus_verbs:МЫЧАТЬ{}, // В огромной куче тел жалобно мычали задавленные трупами и раненые бизоны. (МЫЧАТЬ)
rus_verbs:РАЗБОЙНИЧАТЬ{}, // Эти существа обычно разбойничали в трехстах милях отсюда (РАЗБОЙНИЧАТЬ)
rus_verbs:МАЯЧИТЬ{}, // В отдалении маячили огромные серые туши мастодонтов и мамонтов с изогнутыми бивнями. (МАЯЧИТЬ/ЗАМАЯЧИТЬ)
rus_verbs:ЗАМАЯЧИТЬ{},
rus_verbs:НЕСТИСЬ{}, // Кони неслись вперед в свободном и легком галопе (НЕСТИСЬ)
rus_verbs:ДОБЫТЬ{}, // Они надеялись застать "медвежий народ" врасплох и добыть в бою голову величайшего из воинов. (ДОБЫТЬ)
rus_verbs:СПУСТИТЬ{}, // Время от времени грохот или вопль объявляли о спущенной где-то во дворце ловушке. (СПУСТИТЬ)
rus_verbs:ОБРАЗОВЫВАТЬСЯ{}, // Она сузила глаза, на лице ее стала образовываться маска безумия. (ОБРАЗОВЫВАТЬСЯ)
rus_verbs:КИШЕТЬ{}, // в этом районе кишмя кишели разбойники и драконы. (КИШЕТЬ)
rus_verbs:ДЫШАТЬ{}, // Она тяжело дышала в тисках гнева (ДЫШАТЬ)
rus_verbs:ЗАДЕВАТЬ{}, // тот задевал в нем какую-то струну (ЗАДЕВАТЬ)
rus_verbs:УСТУПИТЬ{}, // Так что теперь уступи мне в этом. (УСТУПИТЬ)
rus_verbs:ТЕРЯТЬ{}, // Хотя он хорошо питался, он терял в весе (ТЕРЯТЬ/ПОТЕРЯТЬ)
rus_verbs:ПоТЕРЯТЬ{},
rus_verbs:УТЕРЯТЬ{},
rus_verbs:РАСТЕРЯТЬ{},
rus_verbs:СМЫКАТЬСЯ{}, // Словно медленно смыкающийся во сне глаз, отверстие медленно закрывалось. (СМЫКАТЬСЯ/СОМКНУТЬСЯ, + оборот с СЛОВНО/БУДТО + вин.п.)
rus_verbs:СОМКНУТЬСЯ{},
rus_verbs:РАЗВОРОШИТЬ{}, // Вольф не узнал никаких отдельных слов, но звуки и взаимодействующая высота тонов разворошили что-то в его памяти. (РАЗВОРОШИТЬ)
rus_verbs:ПРОСТОЯТЬ{}, // Он поднялся и некоторое время простоял в задумчивости. (ПРОСТОЯТЬ,ВЫСТОЯТЬ,ПОСТОЯТЬ)
rus_verbs:ВЫСТОЯТЬ{},
rus_verbs:ПОСТОЯТЬ{},
rus_verbs:ВЗВЕСИТЬ{}, // Он поднял и взвесил в руке один из рогов изобилия. (ВЗВЕСИТЬ/ВЗВЕШИВАТЬ)
rus_verbs:ВЗВЕШИВАТЬ{},
rus_verbs:ДРЕЙФОВАТЬ{}, // Он и тогда не упадет, а будет дрейфовать в отбрасываемой диском тени. (ДРЕЙФОВАТЬ)
прилагательное:быстрый{}, // Кисель быстр в приготовлении
rus_verbs:призвать{}, // В День Воли белорусов призвали побороть страх и лень
rus_verbs:призывать{},
rus_verbs:ВОСПОЛЬЗОВАТЬСЯ{}, // этими деньгами смогу воспользоваться в отпуске (ВОСПОЛЬЗОВАТЬСЯ)
rus_verbs:КОНКУРИРОВАТЬ{}, // Наши клубы могли бы в Англии конкурировать с лидерами (КОНКУРИРОВАТЬ)
rus_verbs:ПОЗВАТЬ{}, // Американскую телеведущую позвали замуж в прямом эфире (ПОЗВАТЬ)
rus_verbs:ВЫХОДИТЬ{}, // Районные газеты Вологодчины будут выходить в цвете и новом формате (ВЫХОДИТЬ)
rus_verbs:РАЗВОРАЧИВАТЬСЯ{}, // Сюжет фэнтези разворачивается в двух мирах (РАЗВОРАЧИВАТЬСЯ)
rus_verbs:ОБСУДИТЬ{}, // В Самаре обсудили перспективы информатизации ветеринарии (ОБСУДИТЬ)
rus_verbs:ВЗДРОГНУТЬ{}, // она сильно вздрогнула во сне (ВЗДРОГНУТЬ)
rus_verbs:ПРЕДСТАВЛЯТЬ{}, // Сенаторы, представляющие в Комитете по разведке обе партии, поддержали эту просьбу (ПРЕДСТАВЛЯТЬ)
rus_verbs:ДОМИНИРОВАТЬ{}, // в химическом составе одной из планет доминирует метан (ДОМИНИРОВАТЬ)
rus_verbs:ОТКРЫТЬ{}, // Крым открыл в Москве собственный туристический офис (ОТКРЫТЬ)
rus_verbs:ПОКАЗАТЬ{}, // В Пушкинском музее показали золото инков (ПОКАЗАТЬ)
rus_verbs:наблюдать{}, // Наблюдаемый в отражении цвет излучения
rus_verbs:ПРОЛЕТЕТЬ{}, // Крупный астероид пролетел в непосредственной близости от Земли (ПРОЛЕТЕТЬ)
rus_verbs:РАССЛЕДОВАТЬ{}, // В Дагестане расследуют убийство федерального судьи (РАССЛЕДОВАТЬ)
rus_verbs:ВОЗОБНОВИТЬСЯ{}, // В Кемеровской области возобновилось движение по трассам международного значения (ВОЗОБНОВИТЬСЯ)
rus_verbs:ИЗМЕНИТЬСЯ{}, // изменилась она во всем (ИЗМЕНИТЬСЯ)
rus_verbs:СВЕРКАТЬ{}, // за широким окном комнаты город сверкал во тьме разноцветными огнями (СВЕРКАТЬ)
rus_verbs:СКОНЧАТЬСЯ{}, // В Риме скончался режиссёр знаменитого сериала «Спрут» (СКОНЧАТЬСЯ)
rus_verbs:ПРЯТАТЬСЯ{}, // Cкрытые спутники прячутся в кольцах Сатурна (ПРЯТАТЬСЯ)
rus_verbs:ВЫЗЫВАТЬ{}, // этот человек всегда вызывал во мне восхищение (ВЫЗЫВАТЬ)
rus_verbs:ВЫПУСТИТЬ{}, // Избирательные бюллетени могут выпустить в форме брошюры (ВЫПУСТИТЬ)
rus_verbs:НАЧИНАТЬСЯ{}, // В Москве начинается «марш в защиту детей» (НАЧИНАТЬСЯ)
rus_verbs:ЗАСТРЕЛИТЬ{}, // В Дагестане застрелили преподавателя медресе (ЗАСТРЕЛИТЬ)
rus_verbs:УРАВНЯТЬ{}, // Госзаказчиков уравняют в правах с поставщиками (УРАВНЯТЬ)
rus_verbs:промахнуться{}, // в первой половине невероятным образом промахнулся экс-форвард московского ЦСКА
rus_verbs:ОБЫГРАТЬ{}, // "Рубин" сенсационно обыграл в Мадриде вторую команду Испании (ОБЫГРАТЬ)
rus_verbs:ВКЛЮЧИТЬ{}, // В Челябинской области включен аварийный роуминг (ВКЛЮЧИТЬ)
rus_verbs:УЧАСТИТЬСЯ{}, // В селах Балаковского района участились случаи поджогов стогов сена (УЧАСТИТЬСЯ)
rus_verbs:СПАСТИ{}, // В Австралии спасли повисшего на проводе коршуна (СПАСТИ)
rus_verbs:ВЫПАСТЬ{}, // Отдельные фрагменты достигли земли, выпав в виде метеоритного дождя (ВЫПАСТЬ)
rus_verbs:НАГРАДИТЬ{}, // В Лондоне наградили лауреатов премии Brit Awards (НАГРАДИТЬ)
rus_verbs:ОТКРЫТЬСЯ{}, // в Москве открылся первый международный кинофестиваль
rus_verbs:ПОДНИМАТЬСЯ{}, // во мне поднималось раздражение
rus_verbs:ЗАВЕРШИТЬСЯ{}, // В Италии завершился традиционный Венецианский карнавал (ЗАВЕРШИТЬСЯ)
инфинитив:проводить{ вид:несоверш }, // Кузбасские депутаты проводят в Кемерове прием граждан
глагол:проводить{ вид:несоверш },
деепричастие:проводя{},
rus_verbs:отсутствовать{}, // Хозяйка квартиры в этот момент отсутствовала
rus_verbs:доложить{}, // об итогах своего визита он намерен доложить в американском сенате и Белом доме (ДОЛОЖИТЬ ОБ, В предл)
rus_verbs:ИЗДЕВАТЬСЯ{}, // В Эйлате издеваются над туристами (ИЗДЕВАТЬСЯ В предл)
rus_verbs:НАРУШИТЬ{}, // В нескольких регионах нарушено наземное транспортное сообщение (НАРУШИТЬ В предл)
rus_verbs:БЕЖАТЬ{}, // далеко внизу во тьме бежала невидимая река (БЕЖАТЬ В предл)
rus_verbs:СОБРАТЬСЯ{}, // Дмитрий оглядел собравшихся во дворе мальчишек (СОБРАТЬСЯ В предл)
rus_verbs:ПОСЛЫШАТЬСЯ{}, // далеко вверху во тьме послышался ответ (ПОСЛЫШАТЬСЯ В предл)
rus_verbs:ПОКАЗАТЬСЯ{}, // во дворе показалась высокая фигура (ПОКАЗАТЬСЯ В предл)
rus_verbs:УЛЫБНУТЬСЯ{}, // Дмитрий горько улыбнулся во тьме (УЛЫБНУТЬСЯ В предл)
rus_verbs:ТЯНУТЬСЯ{}, // убежища тянулись во всех направлениях (ТЯНУТЬСЯ В предл)
rus_verbs:РАНИТЬ{}, // В американском университете ранили человека (РАНИТЬ В предл)
rus_verbs:ЗАХВАТИТЬ{}, // Пираты освободили корабль, захваченный в Гвинейском заливе (ЗАХВАТИТЬ В предл)
rus_verbs:РАЗБЕГАТЬСЯ{}, // люди разбегались во всех направлениях (РАЗБЕГАТЬСЯ В предл)
rus_verbs:ПОГАСНУТЬ{}, // во всем доме погас свет (ПОГАСНУТЬ В предл)
rus_verbs:ПОШЕВЕЛИТЬСЯ{}, // Дмитрий пошевелился во сне (ПОШЕВЕЛИТЬСЯ В предл)
rus_verbs:ЗАСТОНАТЬ{}, // раненый застонал во сне (ЗАСТОНАТЬ В предл)
прилагательное:ВИНОВАТЫЙ{}, // во всем виновато вино (ВИНОВАТЫЙ В)
rus_verbs:ОСТАВЛЯТЬ{}, // США оставляют в районе Персидского залива только один авианосец (ОСТАВЛЯТЬ В предл)
rus_verbs:ОТКАЗЫВАТЬСЯ{}, // В России отказываются от планов авиагруппы в Арктике (ОТКАЗЫВАТЬСЯ В предл)
rus_verbs:ЛИКВИДИРОВАТЬ{}, // В Кабардино-Балкарии ликвидирован подпольный завод по переработке нефти (ЛИКВИДИРОВАТЬ В предл)
rus_verbs:РАЗОБЛАЧИТЬ{}, // В США разоблачили крупнейшую махинацию с кредитками (РАЗОБЛАЧИТЬ В предл)
rus_verbs:СХВАТИТЬ{}, // их схватили во сне (СХВАТИТЬ В предл)
rus_verbs:НАЧАТЬ{}, // В Белгороде начали сбор подписей за отставку мэра (НАЧАТЬ В предл)
rus_verbs:РАСТИ{}, // Cамая маленькая муха растёт в голове муравья (РАСТИ В предл)
rus_verbs:похитить{}, // Двое россиян, похищенных террористами в Сирии, освобождены (похитить в предл)
rus_verbs:УЧАСТВОВАТЬ{}, // были застрелены два испанских гражданских гвардейца , участвовавших в слежке (УЧАСТВОВАТЬ В)
rus_verbs:УСЫНОВИТЬ{}, // Американцы забирают усыновленных в России детей (УСЫНОВИТЬ В)
rus_verbs:ПРОИЗВЕСТИ{}, // вы не увидите мясо или молоко , произведенное в районе (ПРОИЗВЕСТИ В предл)
rus_verbs:ОРИЕНТИРОВАТЬСЯ{}, // призван помочь госслужащему правильно ориентироваться в сложных нравственных коллизиях (ОРИЕНТИРОВАТЬСЯ В)
rus_verbs:ПОВРЕДИТЬ{}, // В зале игровых автоматов повреждены стены и потолок (ПОВРЕДИТЬ В предл)
rus_verbs:ИЗЪЯТЬ{}, // В настоящее время в детском учреждении изъяты суточные пробы пищи (ИЗЪЯТЬ В предл)
rus_verbs:СОДЕРЖАТЬСЯ{}, // осужденных , содержащихся в помещениях штрафного изолятора (СОДЕРЖАТЬСЯ В)
rus_verbs:ОТЧИСЛИТЬ{}, // был отчислен за неуспеваемость в 2007 году (ОТЧИСЛИТЬ В предл)
rus_verbs:проходить{}, // находился на санкционированном митинге , проходившем в рамках празднования Дня народного единства (проходить в предл)
rus_verbs:ПОДУМЫВАТЬ{}, // сейчас в правительстве Приамурья подумывают о создании специального пункта помощи туристам (ПОДУМЫВАТЬ В)
rus_verbs:ОТРАПОРТОВЫВАТЬ{}, // главы субъектов не просто отрапортовывали в Москве (ОТРАПОРТОВЫВАТЬ В предл)
rus_verbs:ВЕСТИСЬ{}, // в городе ведутся работы по установке праздничной иллюминации (ВЕСТИСЬ В)
rus_verbs:ОДОБРИТЬ{}, // Одобренным в первом чтении законопроектом (ОДОБРИТЬ В)
rus_verbs:ЗАМЫЛИТЬСЯ{}, // ему легче исправлять , то , что замылилось в глазах предыдущего руководства (ЗАМЫЛИТЬСЯ В)
rus_verbs:АВТОРИЗОВАТЬСЯ{}, // потом имеют право авторизоваться в системе Международного бакалавриата (АВТОРИЗОВАТЬСЯ В)
rus_verbs:ОПУСТИТЬСЯ{}, // Россия опустилась в списке на шесть позиций (ОПУСТИТЬСЯ В предл)
rus_verbs:СГОРЕТЬ{}, // Совладелец сгоревшего в Бразилии ночного клуба сдался полиции (СГОРЕТЬ В)
частица:нет{}, // В этом нет сомнения.
частица:нету{}, // В этом нету сомнения.
rus_verbs:поджечь{}, // Поджегший себя в Москве мужчина оказался ветераном-афганцем
rus_verbs:ввести{}, // В Молдавии введен запрет на амнистию или помилование педофилов.
прилагательное:ДОСТУПНЫЙ{}, // Наиболее интересные таблички доступны в основной экспозиции музея (ДОСТУПНЫЙ В)
rus_verbs:ПОВИСНУТЬ{}, // вопрос повис в мглистом демократическом воздухе (ПОВИСНУТЬ В)
rus_verbs:ВЗОРВАТЬ{}, // В Ираке смертник взорвал в мечети группу туркменов (ВЗОРВАТЬ В)
rus_verbs:ОТНЯТЬ{}, // В Финляндии у россиянки, прибывшей по туристической визе, отняли детей (ОТНЯТЬ В)
rus_verbs:НАЙТИ{}, // Я недавно посетил врача и у меня в глазах нашли какую-то фигню (НАЙТИ В предл)
rus_verbs:ЗАСТРЕЛИТЬСЯ{}, // Девушка, застрелившаяся в центре Киева, была замешана в скандале с влиятельными людьми (ЗАСТРЕЛИТЬСЯ В)
rus_verbs:стартовать{}, // В Страсбурге сегодня стартует зимняя сессия Парламентской ассамблеи Совета Европы (стартовать в)
rus_verbs:ЗАКЛАДЫВАТЬСЯ{}, // Отношение к деньгам закладывается в детстве (ЗАКЛАДЫВАТЬСЯ В)
rus_verbs:НАПИВАТЬСЯ{}, // Депутатам помешают напиваться в здании Госдумы (НАПИВАТЬСЯ В)
rus_verbs:ВЫПРАВИТЬСЯ{}, // Прежде всего было заявлено, что мировая экономика каким-то образом сама выправится в процессе бизнес-цикла (ВЫПРАВИТЬСЯ В)
rus_verbs:ЯВЛЯТЬСЯ{}, // она являлась ко мне во всех моих снах (ЯВЛЯТЬСЯ В)
rus_verbs:СТАЖИРОВАТЬСЯ{}, // сейчас я стажируюсь в одной компании (СТАЖИРОВАТЬСЯ В)
rus_verbs:ОБСТРЕЛЯТЬ{}, // Уроженцы Чечни, обстрелявшие полицейских в центре Москвы, арестованы (ОБСТРЕЛЯТЬ В)
rus_verbs:РАСПРОСТРАНИТЬ{}, // Воски — распространённые в растительном и животном мире сложные эфиры высших жирных кислот и высших высокомолекулярных спиртов (РАСПРОСТРАНИТЬ В)
rus_verbs:ПРИВЕСТИ{}, // Сравнительная фугасность некоторых взрывчатых веществ приведена в следующей таблице (ПРИВЕСТИ В)
rus_verbs:ЗАПОДОЗРИТЬ{}, // Чиновников Минкультуры заподозрили в афере с заповедными землями (ЗАПОДОЗРИТЬ В)
rus_verbs:НАСТУПАТЬ{}, // В Гренландии стали наступать ледники (НАСТУПАТЬ В)
rus_verbs:ВЫДЕЛЯТЬСЯ{}, // В истории Земли выделяются следующие ледниковые эры (ВЫДЕЛЯТЬСЯ В)
rus_verbs:ПРЕДСТАВИТЬ{}, // Данные представлены в хронологическом порядке (ПРЕДСТАВИТЬ В)
rus_verbs:ОБРУШИТЬСЯ{}, // В Северной Осетии на воинскую часть обрушилась снежная лавина (ОБРУШИТЬСЯ В, НА)
rus_verbs:ПОДАВАТЬ{}, // Готовые компоты подают в столовых и кафе (ПОДАВАТЬ В)
rus_verbs:ГОТОВИТЬ{}, // Сегодня компот готовят в домашних условиях из сухофруктов или замороженных фруктов и ягод (ГОТОВИТЬ В)
rus_verbs:ВОЗДЕЛЫВАТЬСЯ{}, // в настоящее время он повсеместно возделывается в огородах (ВОЗДЕЛЫВАТЬСЯ В)
rus_verbs:РАСКЛАДЫВАТЬ{}, // Созревшие семенные экземпляры раскладывают на солнце или в теплом месте, где они делаются мягкими (РАСКЛАДЫВАТЬСЯ В, НА)
rus_verbs:РАСКЛАДЫВАТЬСЯ{},
rus_verbs:СОБИРАТЬСЯ{}, // Обыкновенно огурцы собираются в полуспелом состоянии (СОБИРАТЬСЯ В)
rus_verbs:ПРОГРЕМЕТЬ{}, // В торговом центре Ижевска прогремел взрыв (ПРОГРЕМЕТЬ В)
rus_verbs:СНЯТЬ{}, // чтобы снять их во всей красоте. (СНЯТЬ В)
rus_verbs:ЯВИТЬСЯ{}, // она явилась к нему во сне. (ЯВИТЬСЯ В)
rus_verbs:ВЕРИТЬ{}, // мы же во всем верили капитану. (ВЕРИТЬ В предл)
rus_verbs:выдержать{}, // Игра выдержана в научно-фантастическом стиле. (ВЫДЕРЖАННЫЙ В)
rus_verbs:ПРЕОДОЛЕТЬ{}, // мы пытались преодолеть ее во многих местах. (ПРЕОДОЛЕТЬ В)
инфинитив:НАПИСАТЬ{ aux stress="напис^ать" }, // Программа, написанная в спешке, выполнила недопустимую операцию. (НАПИСАТЬ В)
глагол:НАПИСАТЬ{ aux stress="напис^ать" },
прилагательное:НАПИСАННЫЙ{},
rus_verbs:ЕСТЬ{}, // ты даже во сне ел. (ЕСТЬ/кушать В)
rus_verbs:УСЕСТЬСЯ{}, // Он удобно уселся в кресле. (УСЕСТЬСЯ В)
rus_verbs:ТОРГОВАТЬ{}, // Он торгует в палатке. (ТОРГОВАТЬ В)
rus_verbs:СОВМЕСТИТЬ{}, // Он совместил в себе писателя и художника. (СОВМЕСТИТЬ В)
rus_verbs:ЗАБЫВАТЬ{}, // об этом нельзя забывать даже во сне. (ЗАБЫВАТЬ В)
rus_verbs:поговорить{}, // Давайте поговорим об этом в присутствии адвоката
rus_verbs:убрать{}, // В вагонах метро для комфорта пассажиров уберут сиденья (УБРАТЬ В, ДЛЯ)
rus_verbs:упасть{}, // В Таиланде на автобус с российскими туристами упал башенный кран (УПАСТЬ В, НА)
rus_verbs:раскрыть{}, // В России раскрыли крупнейшую в стране сеть фальшивомонетчиков (РАСКРЫТЬ В)
rus_verbs:соединить{}, // соединить в себе (СОЕДИНИТЬ В предл)
rus_verbs:избрать{}, // В Южной Корее избран новый президент (ИЗБРАТЬ В предл)
rus_verbs:проводиться{}, // Обыски проводятся в воронежском Доме прав человека (ПРОВОДИТЬСЯ В)
безлич_глагол:хватает{}, // В этой статье не хватает ссылок на источники информации. (БЕЗЛИЧ хватать в)
rus_verbs:наносить{}, // В ближнем бою наносит мощные удары своим костлявым кулаком. (НАНОСИТЬ В + предл.)
rus_verbs:расщепляться{}, // Сахароза же быстро расщепляется в пищеварительном тракте на глюкозу и фруктозу (РАСЩЕПЛЯТЬСЯ В, НА)
прилагательное:известный{}, // В Европе сахар был известен ещё римлянам. (ИЗВЕСТНЫЙ В)
rus_verbs:выработать{}, // Способы, выработанные во Франции, перешли затем в Германию и другие страны Европы. (ВЫРАБОТАТЬ В)
rus_verbs:КУЛЬТИВИРОВАТЬСЯ{}, // Культивируется в регионах с умеренным климатом с умеренным количеством осадков и требует плодородной почвы. (КУЛЬТИВИРОВАТЬСЯ В)
rus_verbs:чаять{}, // мама души не чаяла в своих детях (ЧАЯТЬ В)
rus_verbs:улыбаться{}, // Вадим улыбался во сне. (УЛЫБАТЬСЯ В)
rus_verbs:растеряться{}, // Приезжие растерялись в бетонном лабиринте улиц (РАСТЕРЯТЬСЯ В)
rus_verbs:выть{}, // выли волки где-то в лесу (ВЫТЬ В)
rus_verbs:ЗАВЕРИТЬ{}, // выступавший заверил нас в намерении выполнить обещание (ЗАВЕРИТЬ В)
rus_verbs:ИСЧЕЗНУТЬ{}, // звери исчезли во мраке. (ИСЧЕЗНУТЬ В)
rus_verbs:ВСТАТЬ{}, // встать во главе человечества. (ВСТАТЬ В)
rus_verbs:УПОТРЕБЛЯТЬ{}, // В Тибете употребляют кирпичный зелёный чай. (УПОТРЕБЛЯТЬ В)
rus_verbs:ПОДАВАТЬСЯ{}, // Напиток охлаждается и подаётся в холодном виде. (ПОДАВАТЬСЯ В)
rus_verbs:ИСПОЛЬЗОВАТЬСЯ{}, // в игре используются текстуры большего разрешения (ИСПОЛЬЗОВАТЬСЯ В)
rus_verbs:объявить{}, // В газете объявили о конкурсе.
rus_verbs:ВСПЫХНУТЬ{}, // во мне вспыхнул гнев. (ВСПЫХНУТЬ В)
rus_verbs:КРЫТЬСЯ{}, // В его словах кроется угроза. (КРЫТЬСЯ В)
rus_verbs:подняться{}, // В классе вдруг поднялся шум. (подняться в)
rus_verbs:наступить{}, // В классе наступила полная тишина. (наступить в)
rus_verbs:кипеть{}, // В нём кипит злоба. (кипеть в)
rus_verbs:соединиться{}, // В нём соединились храбрость и великодушие. (соединиться в)
инфинитив:ПАРИТЬ{ aux stress="пар^ить"}, // Высоко в небе парит орёл, плавно описывая круги. (ПАРИТЬ В)
глагол:ПАРИТЬ{ aux stress="пар^ить"},
деепричастие:паря{ aux stress="пар^я" },
прилагательное:ПАРЯЩИЙ{},
прилагательное:ПАРИВШИЙ{},
rus_verbs:СИЯТЬ{}, // Главы собора сияли в лучах солнца. (СИЯТЬ В)
rus_verbs:РАСПОЛОЖИТЬ{}, // Гостиница расположена глубоко в горах. (РАСПОЛОЖИТЬ В)
rus_verbs:развиваться{}, // Действие в комедии развивается в двух планах. (развиваться в)
rus_verbs:ПОСАДИТЬ{}, // Дети посадили у нас во дворе цветы. (ПОСАДИТЬ В)
rus_verbs:ИСКОРЕНЯТЬ{}, // Дурные привычки следует искоренять в самом начале. (ИСКОРЕНЯТЬ В)
rus_verbs:ВОССТАНОВИТЬ{}, // Его восстановили в правах. (ВОССТАНОВИТЬ В)
rus_verbs:ПОЛАГАТЬСЯ{}, // мы полагаемся на него в этих вопросах (ПОЛАГАТЬСЯ В)
rus_verbs:УМИРАТЬ{}, // они умирали во сне. (УМИРАТЬ В)
rus_verbs:ПРИБАВИТЬ{}, // Она сильно прибавила в весе. (ПРИБАВИТЬ В)
rus_verbs:посмотреть{}, // Посмотрите в списке. (посмотреть в)
rus_verbs:производиться{}, // Выдача новых паспортов будет производиться в следующем порядке (производиться в)
rus_verbs:принять{}, // Документ принят в следующей редакции (принять в)
rus_verbs:сверкнуть{}, // меч его сверкнул во тьме. (сверкнуть в)
rus_verbs:ВЫРАБАТЫВАТЬ{}, // ты должен вырабатывать в себе силу воли (ВЫРАБАТЫВАТЬ В)
rus_verbs:достать{}, // Эти сведения мы достали в Волгограде. (достать в)
rus_verbs:звучать{}, // в доме звучала музыка (звучать в)
rus_verbs:колебаться{}, // колеблется в выборе (колебаться в)
rus_verbs:мешать{}, // мешать в кастрюле суп (мешать в)
rus_verbs:нарастать{}, // во мне нарастал гнев (нарастать в)
rus_verbs:отбыть{}, // Вадим отбыл в неизвестном направлении (отбыть в)
rus_verbs:светиться{}, // во всем доме светилось только окно ее спальни. (светиться в)
rus_verbs:вычитывать{}, // вычитывать в книге
rus_verbs:гудеть{}, // У него в ушах гудит.
rus_verbs:давать{}, // В этой лавке дают в долг?
rus_verbs:поблескивать{}, // Красивое стеклышко поблескивало в пыльной траве у дорожки.
rus_verbs:разойтись{}, // Они разошлись в темноте.
rus_verbs:прибежать{}, // Мальчик прибежал в слезах.
rus_verbs:биться{}, // Она билась в истерике.
rus_verbs:регистрироваться{}, // регистрироваться в системе
rus_verbs:считать{}, // я буду считать в уме
rus_verbs:трахаться{}, // трахаться в гамаке
rus_verbs:сконцентрироваться{}, // сконцентрироваться в одной точке
rus_verbs:разрушать{}, // разрушать в дробилке
rus_verbs:засидеться{}, // засидеться в гостях
rus_verbs:засиживаться{}, // засиживаться в гостях
rus_verbs:утопить{}, // утопить лодку в реке (утопить в реке)
rus_verbs:навестить{}, // навестить в доме престарелых
rus_verbs:запомнить{}, // запомнить в кэше
rus_verbs:убивать{}, // убивать в помещении полиции (-score убивать неодуш. дом.)
rus_verbs:базироваться{}, // установка базируется в черте города (ngram черта города - проверить что есть проверка)
rus_verbs:покупать{}, // Чаще всего россияне покупают в интернете бытовую технику.
rus_verbs:ходить{}, // ходить в пальто (сделать ХОДИТЬ + в + ОДЕЖДА предл.п.)
rus_verbs:заложить{}, // диверсанты заложили в помещении бомбу
rus_verbs:оглядываться{}, // оглядываться в зеркале
rus_verbs:нарисовать{}, // нарисовать в тетрадке
rus_verbs:пробить{}, // пробить отверствие в стене
rus_verbs:повертеть{}, // повертеть в руке
rus_verbs:вертеть{}, // Я вертел в руках
rus_verbs:рваться{}, // Веревка рвется в месте надреза
rus_verbs:распространяться{}, // распространяться в среде наркоманов
rus_verbs:попрощаться{}, // попрощаться в здании морга
rus_verbs:соображать{}, // соображать в уме
инфинитив:просыпаться{ вид:несоверш }, глагол:просыпаться{ вид:несоверш }, // просыпаться в чужой кровати
rus_verbs:заехать{}, // Коля заехал в гости (в гости - устойчивый наречный оборот)
rus_verbs:разобрать{}, // разобрать в гараже
rus_verbs:помереть{}, // помереть в пути
rus_verbs:различить{}, // различить в темноте
rus_verbs:рисовать{}, // рисовать в графическом редакторе
rus_verbs:проследить{}, // проследить в записях камер слежения
rus_verbs:совершаться{}, // Правосудие совершается в суде
rus_verbs:задремать{}, // задремать в кровати
rus_verbs:ругаться{}, // ругаться в комнате
rus_verbs:зазвучать{}, // зазвучать в радиоприемниках
rus_verbs:задохнуться{}, // задохнуться в воде
rus_verbs:порождать{}, // порождать в неокрепших умах
rus_verbs:отдыхать{}, // отдыхать в санатории
rus_verbs:упоминаться{}, // упоминаться в предыдущем сообщении
rus_verbs:образовать{}, // образовать в пробирке темную взвесь
rus_verbs:отмечать{}, // отмечать в списке
rus_verbs:подчеркнуть{}, // подчеркнуть в блокноте
rus_verbs:плясать{}, // плясать в откружении незнакомых людей
rus_verbs:повысить{}, // повысить в звании
rus_verbs:поджидать{}, // поджидать в подъезде
rus_verbs:отказать{}, // отказать в пересмотре дела
rus_verbs:раствориться{}, // раствориться в бензине
rus_verbs:отражать{}, // отражать в стихах
rus_verbs:дремать{}, // дремать в гамаке
rus_verbs:применяться{}, // применяться в домашних условиях
rus_verbs:присниться{}, // присниться во сне
rus_verbs:трястись{}, // трястись в драндулете
rus_verbs:сохранять{}, // сохранять в неприкосновенности
rus_verbs:расстрелять{}, // расстрелять в ложбине
rus_verbs:рассчитать{}, // рассчитать в программе
rus_verbs:перебирать{}, // перебирать в руке
rus_verbs:разбиться{}, // разбиться в аварии
rus_verbs:поискать{}, // поискать в углу
rus_verbs:мучиться{}, // мучиться в тесной клетке
rus_verbs:замелькать{}, // замелькать в телевизоре
rus_verbs:грустить{}, // грустить в одиночестве
rus_verbs:крутить{}, // крутить в банке
rus_verbs:объявиться{}, // объявиться в городе
rus_verbs:подготовить{}, // подготовить в тайне
rus_verbs:различать{}, // различать в смеси
rus_verbs:обнаруживать{}, // обнаруживать в крови
rus_verbs:киснуть{}, // киснуть в захолустье
rus_verbs:оборваться{}, // оборваться в начале фразы
rus_verbs:запутаться{}, // запутаться в веревках
rus_verbs:общаться{}, // общаться в интимной обстановке
rus_verbs:сочинить{}, // сочинить в ресторане
rus_verbs:изобрести{}, // изобрести в домашней лаборатории
rus_verbs:прокомментировать{}, // прокомментировать в своем блоге
rus_verbs:давить{}, // давить в зародыше
rus_verbs:повториться{}, // повториться в новом обличье
rus_verbs:отставать{}, // отставать в общем зачете
rus_verbs:разработать{}, // разработать в лаборатории
rus_verbs:качать{}, // качать в кроватке
rus_verbs:заменить{}, // заменить в двигателе
rus_verbs:задыхаться{}, // задыхаться в душной и влажной атмосфере
rus_verbs:забегать{}, // забегать в спешке
rus_verbs:наделать{}, // наделать в решении ошибок
rus_verbs:исказиться{}, // исказиться в кривом зеркале
rus_verbs:тушить{}, // тушить в помещении пожар
rus_verbs:охранять{}, // охранять в здании входы
rus_verbs:приметить{}, // приметить в кустах
rus_verbs:скрыть{}, // скрыть в складках одежды
rus_verbs:удерживать{}, // удерживать в заложниках
rus_verbs:увеличиваться{}, // увеличиваться в размере
rus_verbs:красоваться{}, // красоваться в новом платье
rus_verbs:сохраниться{}, // сохраниться в тепле
rus_verbs:лечить{}, // лечить в стационаре
rus_verbs:смешаться{}, // смешаться в баке
rus_verbs:прокатиться{}, // прокатиться в троллейбусе
rus_verbs:договариваться{}, // договариваться в закрытом кабинете
rus_verbs:опубликовать{}, // опубликовать в официальном блоге
rus_verbs:охотиться{}, // охотиться в прериях
rus_verbs:отражаться{}, // отражаться в окне
rus_verbs:понизить{}, // понизить в должности
rus_verbs:обедать{}, // обедать в ресторане
rus_verbs:посидеть{}, // посидеть в тени
rus_verbs:сообщаться{}, // сообщаться в оппозиционной газете
rus_verbs:свершиться{}, // свершиться в суде
rus_verbs:ночевать{}, // ночевать в гостинице
rus_verbs:темнеть{}, // темнеть в воде
rus_verbs:гибнуть{}, // гибнуть в застенках
rus_verbs:усиливаться{}, // усиливаться в направлении главного удара
rus_verbs:расплыться{}, // расплыться в улыбке
rus_verbs:превышать{}, // превышать в несколько раз
rus_verbs:проживать{}, // проживать в отдельной коморке
rus_verbs:голубеть{}, // голубеть в тепле
rus_verbs:исследовать{}, // исследовать в естественных условиях
rus_verbs:обитать{}, // обитать в лесу
rus_verbs:скучать{}, // скучать в одиночестве
rus_verbs:сталкиваться{}, // сталкиваться в воздухе
rus_verbs:таиться{}, // таиться в глубине
rus_verbs:спасать{}, // спасать в море
rus_verbs:заблудиться{}, // заблудиться в лесу
rus_verbs:создаться{}, // создаться в новом виде
rus_verbs:пошарить{}, // пошарить в кармане
rus_verbs:планировать{}, // планировать в программе
rus_verbs:отбить{}, // отбить в нижней части
rus_verbs:отрицать{}, // отрицать в суде свою вину
rus_verbs:основать{}, // основать в пустыне новый город
rus_verbs:двоить{}, // двоить в глазах
rus_verbs:устоять{}, // устоять в лодке
rus_verbs:унять{}, // унять в ногах дрожь
rus_verbs:отзываться{}, // отзываться в обзоре
rus_verbs:притормозить{}, // притормозить в траве
rus_verbs:читаться{}, // читаться в глазах
rus_verbs:житься{}, // житься в деревне
rus_verbs:заиграть{}, // заиграть в жилах
rus_verbs:шевелить{}, // шевелить в воде
rus_verbs:зазвенеть{}, // зазвенеть в ушах
rus_verbs:зависнуть{}, // зависнуть в библиотеке
rus_verbs:затаить{}, // затаить в душе обиду
rus_verbs:сознаться{}, // сознаться в совершении
rus_verbs:протекать{}, // протекать в легкой форме
rus_verbs:выясняться{}, // выясняться в ходе эксперимента
rus_verbs:скрестить{}, // скрестить в неволе
rus_verbs:наводить{}, // наводить в комнате порядок
rus_verbs:значиться{}, // значиться в документах
rus_verbs:заинтересовать{}, // заинтересовать в получении результатов
rus_verbs:познакомить{}, // познакомить в непринужденной обстановке
rus_verbs:рассеяться{}, // рассеяться в воздухе
rus_verbs:грохнуть{}, // грохнуть в подвале
rus_verbs:обвинять{}, // обвинять в вымогательстве
rus_verbs:столпиться{}, // столпиться в фойе
rus_verbs:порыться{}, // порыться в сумке
rus_verbs:ослабить{}, // ослабить в верхней части
rus_verbs:обнаруживаться{}, // обнаруживаться в кармане куртки
rus_verbs:спастись{}, // спастись в хижине
rus_verbs:прерваться{}, // прерваться в середине фразы
rus_verbs:применять{}, // применять в повседневной работе
rus_verbs:строиться{}, // строиться в зоне отчуждения
rus_verbs:путешествовать{}, // путешествовать в самолете
rus_verbs:побеждать{}, // побеждать в честной битве
rus_verbs:погубить{}, // погубить в себе артиста
rus_verbs:рассматриваться{}, // рассматриваться в следующей главе
rus_verbs:продаваться{}, // продаваться в специализированном магазине
rus_verbs:разместиться{}, // разместиться в аудитории
rus_verbs:повидать{}, // повидать в жизни
rus_verbs:настигнуть{}, // настигнуть в пригородах
rus_verbs:сгрудиться{}, // сгрудиться в центре загона
rus_verbs:укрыться{}, // укрыться в доме
rus_verbs:расплакаться{}, // расплакаться в суде
rus_verbs:пролежать{}, // пролежать в канаве
rus_verbs:замерзнуть{}, // замерзнуть в ледяной воде
rus_verbs:поскользнуться{}, // поскользнуться в коридоре
rus_verbs:таскать{}, // таскать в руках
rus_verbs:нападать{}, // нападать в вольере
rus_verbs:просматривать{}, // просматривать в браузере
rus_verbs:обдумать{}, // обдумать в дороге
rus_verbs:обвинить{}, // обвинить в измене
rus_verbs:останавливать{}, // останавливать в дверях
rus_verbs:теряться{}, // теряться в догадках
rus_verbs:погибать{}, // погибать в бою
rus_verbs:обозначать{}, // обозначать в списке
rus_verbs:запрещать{}, // запрещать в парке
rus_verbs:долететь{}, // долететь в вертолёте
rus_verbs:тесниться{}, // тесниться в каморке
rus_verbs:уменьшаться{}, // уменьшаться в размере
rus_verbs:издавать{}, // издавать в небольшом издательстве
rus_verbs:хоронить{}, // хоронить в море
rus_verbs:перемениться{}, // перемениться в лице
rus_verbs:установиться{}, // установиться в северных областях
rus_verbs:прикидывать{}, // прикидывать в уме
rus_verbs:затаиться{}, // затаиться в траве
rus_verbs:раздобыть{}, // раздобыть в аптеке
rus_verbs:перебросить{}, // перебросить в товарном составе
rus_verbs:погружаться{}, // погружаться в батискафе
rus_verbs:поживать{}, // поживать в одиночестве
rus_verbs:признаваться{}, // признаваться в любви
rus_verbs:захватывать{}, // захватывать в здании
rus_verbs:покачиваться{}, // покачиваться в лодке
rus_verbs:крутиться{}, // крутиться в колесе
rus_verbs:помещаться{}, // помещаться в ящике
rus_verbs:питаться{}, // питаться в столовой
rus_verbs:отдохнуть{}, // отдохнуть в пансионате
rus_verbs:кататься{}, // кататься в коляске
rus_verbs:поработать{}, // поработать в цеху
rus_verbs:подразумевать{}, // подразумевать в задании
rus_verbs:ограбить{}, // ограбить в подворотне
rus_verbs:преуспеть{}, // преуспеть в бизнесе
rus_verbs:заерзать{}, // заерзать в кресле
rus_verbs:разъяснить{}, // разъяснить в другой статье
rus_verbs:продвинуться{}, // продвинуться в изучении
rus_verbs:поколебаться{}, // поколебаться в начале
rus_verbs:засомневаться{}, // засомневаться в честности
rus_verbs:приникнуть{}, // приникнуть в уме
rus_verbs:скривить{}, // скривить в усмешке
rus_verbs:рассечь{}, // рассечь в центре опухоли
rus_verbs:перепутать{}, // перепутать в роддоме
rus_verbs:посмеяться{}, // посмеяться в перерыве
rus_verbs:отмечаться{}, // отмечаться в полицейском участке
rus_verbs:накопиться{}, // накопиться в отстойнике
rus_verbs:уносить{}, // уносить в руках
rus_verbs:навещать{}, // навещать в больнице
rus_verbs:остыть{}, // остыть в проточной воде
rus_verbs:запереться{}, // запереться в комнате
rus_verbs:обогнать{}, // обогнать в первом круге
rus_verbs:убеждаться{}, // убеждаться в неизбежности
rus_verbs:подбирать{}, // подбирать в магазине
rus_verbs:уничтожать{}, // уничтожать в полете
rus_verbs:путаться{}, // путаться в показаниях
rus_verbs:притаиться{}, // притаиться в темноте
rus_verbs:проплывать{}, // проплывать в лодке
rus_verbs:засесть{}, // засесть в окопе
rus_verbs:подцепить{}, // подцепить в баре
rus_verbs:насчитать{}, // насчитать в диктанте несколько ошибок
rus_verbs:оправдаться{}, // оправдаться в суде
rus_verbs:созреть{}, // созреть в естественных условиях
rus_verbs:раскрываться{}, // раскрываться в подходящих условиях
rus_verbs:ожидаться{}, // ожидаться в верхней части
rus_verbs:одеваться{}, // одеваться в дорогих бутиках
rus_verbs:упрекнуть{}, // упрекнуть в недостатке опыта
rus_verbs:грабить{}, // грабить в подворотне
rus_verbs:ужинать{}, // ужинать в ресторане
rus_verbs:гонять{}, // гонять в жилах
rus_verbs:уверить{}, // уверить в безопасности
rus_verbs:потеряться{}, // потеряться в лесу
rus_verbs:устанавливаться{}, // устанавливаться в комнате
rus_verbs:предоставлять{}, // предоставлять в суде
rus_verbs:протянуться{}, // протянуться в стене
rus_verbs:допрашивать{}, // допрашивать в бункере
rus_verbs:проработать{}, // проработать в кабинете
rus_verbs:сосредоточить{}, // сосредоточить в своих руках
rus_verbs:утвердить{}, // утвердить в должности
rus_verbs:сочинять{}, // сочинять в дороге
rus_verbs:померкнуть{}, // померкнуть в глазах
rus_verbs:показываться{}, // показываться в окошке
rus_verbs:похудеть{}, // похудеть в талии
rus_verbs:проделывать{}, // проделывать в стене
rus_verbs:прославиться{}, // прославиться в интернете
rus_verbs:сдохнуть{}, // сдохнуть в нищете
rus_verbs:раскинуться{}, // раскинуться в степи
rus_verbs:развить{}, // развить в себе способности
rus_verbs:уставать{}, // уставать в цеху
rus_verbs:укрепить{}, // укрепить в земле
rus_verbs:числиться{}, // числиться в списке
rus_verbs:образовывать{}, // образовывать в смеси
rus_verbs:екнуть{}, // екнуть в груди
rus_verbs:одобрять{}, // одобрять в своей речи
rus_verbs:запить{}, // запить в одиночестве
rus_verbs:забыться{}, // забыться в тяжелом сне
rus_verbs:чернеть{}, // чернеть в кислой среде
rus_verbs:размещаться{}, // размещаться в гараже
rus_verbs:соорудить{}, // соорудить в гараже
rus_verbs:развивать{}, // развивать в себе
rus_verbs:пастись{}, // пастись в пойме
rus_verbs:формироваться{}, // формироваться в верхних слоях атмосферы
rus_verbs:ослабнуть{}, // ослабнуть в сочленении
rus_verbs:таить{}, // таить в себе
инфинитив:пробегать{ вид:несоверш }, глагол:пробегать{ вид:несоверш }, // пробегать в спешке
rus_verbs:приостановиться{}, // приостановиться в конце
rus_verbs:топтаться{}, // топтаться в грязи
rus_verbs:громить{}, // громить в финале
rus_verbs:заменять{}, // заменять в основном составе
rus_verbs:подъезжать{}, // подъезжать в колясках
rus_verbs:вычислить{}, // вычислить в уме
rus_verbs:заказывать{}, // заказывать в магазине
rus_verbs:осуществить{}, // осуществить в реальных условиях
rus_verbs:обосноваться{}, // обосноваться в дупле
rus_verbs:пытать{}, // пытать в камере
rus_verbs:поменять{}, // поменять в магазине
rus_verbs:совершиться{}, // совершиться в суде
rus_verbs:пролетать{}, // пролетать в вертолете
rus_verbs:сбыться{}, // сбыться во сне
rus_verbs:разговориться{}, // разговориться в отделении
rus_verbs:преподнести{}, // преподнести в красивой упаковке
rus_verbs:напечатать{}, // напечатать в типографии
rus_verbs:прорвать{}, // прорвать в центре
rus_verbs:раскачиваться{}, // раскачиваться в кресле
rus_verbs:задерживаться{}, // задерживаться в дверях
rus_verbs:угощать{}, // угощать в кафе
rus_verbs:проступать{}, // проступать в глубине
rus_verbs:шарить{}, // шарить в математике
rus_verbs:увеличивать{}, // увеличивать в конце
rus_verbs:расцвести{}, // расцвести в оранжерее
rus_verbs:закипеть{}, // закипеть в баке
rus_verbs:подлететь{}, // подлететь в вертолете
rus_verbs:рыться{}, // рыться в куче
rus_verbs:пожить{}, // пожить в гостинице
rus_verbs:добираться{}, // добираться в попутном транспорте
rus_verbs:перекрыть{}, // перекрыть в коридоре
rus_verbs:продержаться{}, // продержаться в барокамере
rus_verbs:разыскивать{}, // разыскивать в толпе
rus_verbs:освобождать{}, // освобождать в зале суда
rus_verbs:подметить{}, // подметить в человеке
rus_verbs:передвигаться{}, // передвигаться в узкой юбке
rus_verbs:продумать{}, // продумать в уме
rus_verbs:извиваться{}, // извиваться в траве
rus_verbs:процитировать{}, // процитировать в статье
rus_verbs:прогуливаться{}, // прогуливаться в парке
rus_verbs:защемить{}, // защемить в двери
rus_verbs:увеличиться{}, // увеличиться в объеме
rus_verbs:проявиться{}, // проявиться в результатах
rus_verbs:заскользить{}, // заскользить в ботинках
rus_verbs:пересказать{}, // пересказать в своем выступлении
rus_verbs:протестовать{}, // протестовать в здании парламента
rus_verbs:указываться{}, // указываться в путеводителе
rus_verbs:копошиться{}, // копошиться в песке
rus_verbs:проигнорировать{}, // проигнорировать в своей работе
rus_verbs:купаться{}, // купаться в речке
rus_verbs:подсчитать{}, // подсчитать в уме
rus_verbs:разволноваться{}, // разволноваться в классе
rus_verbs:придумывать{}, // придумывать в своем воображении
rus_verbs:предусмотреть{}, // предусмотреть в программе
rus_verbs:завертеться{}, // завертеться в колесе
rus_verbs:зачерпнуть{}, // зачерпнуть в ручье
rus_verbs:очистить{}, // очистить в химической лаборатории
rus_verbs:прозвенеть{}, // прозвенеть в коридорах
rus_verbs:уменьшиться{}, // уменьшиться в размере
rus_verbs:колыхаться{}, // колыхаться в проточной воде
rus_verbs:ознакомиться{}, // ознакомиться в автобусе
rus_verbs:ржать{}, // ржать в аудитории
rus_verbs:раскинуть{}, // раскинуть в микрорайоне
rus_verbs:разлиться{}, // разлиться в воде
rus_verbs:сквозить{}, // сквозить в словах
rus_verbs:задушить{}, // задушить в объятиях
rus_verbs:осудить{}, // осудить в особом порядке
rus_verbs:разгромить{}, // разгромить в честном поединке
rus_verbs:подслушать{}, // подслушать в кулуарах
rus_verbs:проповедовать{}, // проповедовать в сельских районах
rus_verbs:озарить{}, // озарить во сне
rus_verbs:потирать{}, // потирать в предвкушении
rus_verbs:описываться{}, // описываться в статье
rus_verbs:качаться{}, // качаться в кроватке
rus_verbs:усилить{}, // усилить в центре
rus_verbs:прохаживаться{}, // прохаживаться в новом костюме
rus_verbs:полечить{}, // полечить в больничке
rus_verbs:сниматься{}, // сниматься в римейке
rus_verbs:сыскать{}, // сыскать в наших краях
rus_verbs:поприветствовать{}, // поприветствовать в коридоре
rus_verbs:подтвердиться{}, // подтвердиться в эксперименте
rus_verbs:плескаться{}, // плескаться в теплой водичке
rus_verbs:расширяться{}, // расширяться в первом сегменте
rus_verbs:мерещиться{}, // мерещиться в тумане
rus_verbs:сгущаться{}, // сгущаться в воздухе
rus_verbs:храпеть{}, // храпеть во сне
rus_verbs:подержать{}, // подержать в руках
rus_verbs:накинуться{}, // накинуться в подворотне
rus_verbs:планироваться{}, // планироваться в закрытом режиме
rus_verbs:пробудить{}, // пробудить в себе
rus_verbs:побриться{}, // побриться в ванной
rus_verbs:сгинуть{}, // сгинуть в пучине
rus_verbs:окрестить{}, // окрестить в церкви
инфинитив:резюмировать{ вид:соверш }, глагол:резюмировать{ вид:соверш }, // резюмировать в конце выступления
rus_verbs:замкнуться{}, // замкнуться в себе
rus_verbs:прибавлять{}, // прибавлять в весе
rus_verbs:проплыть{}, // проплыть в лодке
rus_verbs:растворяться{}, // растворяться в тумане
rus_verbs:упрекать{}, // упрекать в небрежности
rus_verbs:затеряться{}, // затеряться в лабиринте
rus_verbs:перечитывать{}, // перечитывать в поезде
rus_verbs:перелететь{}, // перелететь в вертолете
rus_verbs:оживать{}, // оживать в теплой воде
rus_verbs:заглохнуть{}, // заглохнуть в полете
rus_verbs:кольнуть{}, // кольнуть в боку
rus_verbs:копаться{}, // копаться в куче
rus_verbs:развлекаться{}, // развлекаться в клубе
rus_verbs:отливать{}, // отливать в кустах
rus_verbs:зажить{}, // зажить в деревне
rus_verbs:одолжить{}, // одолжить в соседнем кабинете
rus_verbs:заклинать{}, // заклинать в своей речи
rus_verbs:различаться{}, // различаться в мелочах
rus_verbs:печататься{}, // печататься в типографии
rus_verbs:угадываться{}, // угадываться в контурах
rus_verbs:обрывать{}, // обрывать в начале
rus_verbs:поглаживать{}, // поглаживать в кармане
rus_verbs:подписывать{}, // подписывать в присутствии понятых
rus_verbs:добывать{}, // добывать в разломе
rus_verbs:скопиться{}, // скопиться в воротах
rus_verbs:повстречать{}, // повстречать в бане
rus_verbs:совпасть{}, // совпасть в упрощенном виде
rus_verbs:разрываться{}, // разрываться в точке спайки
rus_verbs:улавливать{}, // улавливать в датчике
rus_verbs:повстречаться{}, // повстречаться в лифте
rus_verbs:отразить{}, // отразить в отчете
rus_verbs:пояснять{}, // пояснять в примечаниях
rus_verbs:накормить{}, // накормить в столовке
rus_verbs:поужинать{}, // поужинать в ресторане
инфинитив:спеть{ вид:соверш }, глагол:спеть{ вид:соверш }, // спеть в суде
инфинитив:спеть{ вид:несоверш }, глагол:спеть{ вид:несоверш },
rus_verbs:топить{}, // топить в молоке
rus_verbs:освоить{}, // освоить в работе
rus_verbs:зародиться{}, // зародиться в голове
rus_verbs:отплыть{}, // отплыть в старой лодке
rus_verbs:отстаивать{}, // отстаивать в суде
rus_verbs:осуждать{}, // осуждать в своем выступлении
rus_verbs:переговорить{}, // переговорить в перерыве
rus_verbs:разгораться{}, // разгораться в сердце
rus_verbs:укрыть{}, // укрыть в шалаше
rus_verbs:томиться{}, // томиться в застенках
rus_verbs:клубиться{}, // клубиться в воздухе
rus_verbs:сжигать{}, // сжигать в топке
rus_verbs:позавтракать{}, // позавтракать в кафешке
rus_verbs:функционировать{}, // функционировать в лабораторных условиях
rus_verbs:смять{}, // смять в руке
rus_verbs:разместить{}, // разместить в интернете
rus_verbs:пронести{}, // пронести в потайном кармане
rus_verbs:руководствоваться{}, // руководствоваться в работе
rus_verbs:нашарить{}, // нашарить в потемках
rus_verbs:закрутить{}, // закрутить в вихре
rus_verbs:просматриваться{}, // просматриваться в дальней перспективе
rus_verbs:распознать{}, // распознать в незнакомце
rus_verbs:повеситься{}, // повеситься в камере
rus_verbs:обшарить{}, // обшарить в поисках наркотиков
rus_verbs:наполняться{}, // наполняется в карьере
rus_verbs:засвистеть{}, // засвистеть в воздухе
rus_verbs:процветать{}, // процветать в мягком климате
rus_verbs:шуршать{}, // шуршать в простенке
rus_verbs:подхватывать{}, // подхватывать в полете
инфинитив:роиться{}, глагол:роиться{}, // роиться в воздухе
прилагательное:роившийся{}, прилагательное:роящийся{},
// деепричастие:роясь{ aux stress="ро^ясь" },
rus_verbs:преобладать{}, // преобладать в тексте
rus_verbs:посветлеть{}, // посветлеть в лице
rus_verbs:игнорировать{}, // игнорировать в рекомендациях
rus_verbs:обсуждаться{}, // обсуждаться в кулуарах
rus_verbs:отказывать{}, // отказывать в визе
rus_verbs:ощупывать{}, // ощупывать в кармане
rus_verbs:разливаться{}, // разливаться в цеху
rus_verbs:расписаться{}, // расписаться в получении
rus_verbs:учинить{}, // учинить в казарме
rus_verbs:плестись{}, // плестись в хвосте
rus_verbs:объявляться{}, // объявляться в группе
rus_verbs:повышаться{}, // повышаться в первой части
rus_verbs:напрягать{}, // напрягать в паху
rus_verbs:разрабатывать{}, // разрабатывать в студии
rus_verbs:хлопотать{}, // хлопотать в мэрии
rus_verbs:прерывать{}, // прерывать в самом начале
rus_verbs:каяться{}, // каяться в грехах
rus_verbs:освоиться{}, // освоиться в кабине
rus_verbs:подплыть{}, // подплыть в лодке
rus_verbs:замигать{}, // замигать в темноте
rus_verbs:оскорблять{}, // оскорблять в выступлении
rus_verbs:торжествовать{}, // торжествовать в душе
rus_verbs:поправлять{}, // поправлять в прологе
rus_verbs:угадывать{}, // угадывать в размытом изображении
rus_verbs:потоптаться{}, // потоптаться в прихожей
rus_verbs:переправиться{}, // переправиться в лодочке
rus_verbs:увериться{}, // увериться в невиновности
rus_verbs:забрезжить{}, // забрезжить в конце тоннеля
rus_verbs:утвердиться{}, // утвердиться во мнении
rus_verbs:завывать{}, // завывать в трубе
rus_verbs:заварить{}, // заварить в заварнике
rus_verbs:скомкать{}, // скомкать в руке
rus_verbs:перемещаться{}, // перемещаться в капсуле
инфинитив:писаться{ aux stress="пис^аться" }, глагол:писаться{ aux stress="пис^аться" }, // писаться в первом поле
rus_verbs:праздновать{}, // праздновать в баре
rus_verbs:мигать{}, // мигать в темноте
rus_verbs:обучить{}, // обучить в мастерской
rus_verbs:орудовать{}, // орудовать в кладовке
rus_verbs:упорствовать{}, // упорствовать в заблуждении
rus_verbs:переминаться{}, // переминаться в прихожей
rus_verbs:подрасти{}, // подрасти в теплице
rus_verbs:предписываться{}, // предписываться в законе
rus_verbs:приписать{}, // приписать в конце
rus_verbs:задаваться{}, // задаваться в своей статье
rus_verbs:чинить{}, // чинить в домашних условиях
rus_verbs:раздеваться{}, // раздеваться в пляжной кабинке
rus_verbs:пообедать{}, // пообедать в ресторанчике
rus_verbs:жрать{}, // жрать в чуланчике
rus_verbs:исполняться{}, // исполняться в антракте
rus_verbs:гнить{}, // гнить в тюрьме
rus_verbs:глодать{}, // глодать в конуре
rus_verbs:прослушать{}, // прослушать в дороге
rus_verbs:истратить{}, // истратить в кабаке
rus_verbs:стареть{}, // стареть в одиночестве
rus_verbs:разжечь{}, // разжечь в сердце
rus_verbs:совещаться{}, // совещаться в кабинете
rus_verbs:покачивать{}, // покачивать в кроватке
rus_verbs:отсидеть{}, // отсидеть в одиночке
rus_verbs:формировать{}, // формировать в умах
rus_verbs:захрапеть{}, // захрапеть во сне
rus_verbs:петься{}, // петься в хоре
rus_verbs:объехать{}, // объехать в автобусе
rus_verbs:поселить{}, // поселить в гостинице
rus_verbs:предаться{}, // предаться в книге
rus_verbs:заворочаться{}, // заворочаться во сне
rus_verbs:напрятать{}, // напрятать в карманах
rus_verbs:очухаться{}, // очухаться в незнакомом месте
rus_verbs:ограничивать{}, // ограничивать в движениях
rus_verbs:завертеть{}, // завертеть в руках
rus_verbs:печатать{}, // печатать в редакторе
rus_verbs:теплиться{}, // теплиться в сердце
rus_verbs:увязнуть{}, // увязнуть в зыбучем песке
rus_verbs:усмотреть{}, // усмотреть в обращении
rus_verbs:отыскаться{}, // отыскаться в запасах
rus_verbs:потушить{}, // потушить в горле огонь
rus_verbs:поубавиться{}, // поубавиться в размере
rus_verbs:зафиксировать{}, // зафиксировать в постоянной памяти
rus_verbs:смыть{}, // смыть в ванной
rus_verbs:заместить{}, // заместить в кресле
rus_verbs:угасать{}, // угасать в одиночестве
rus_verbs:сразить{}, // сразить в споре
rus_verbs:фигурировать{}, // фигурировать в бюллетене
rus_verbs:расплываться{}, // расплываться в глазах
rus_verbs:сосчитать{}, // сосчитать в уме
rus_verbs:сгуститься{}, // сгуститься в воздухе
rus_verbs:цитировать{}, // цитировать в своей статье
rus_verbs:помяться{}, // помяться в давке
rus_verbs:затрагивать{}, // затрагивать в процессе выполнения
rus_verbs:обтереть{}, // обтереть в гараже
rus_verbs:подстрелить{}, // подстрелить в пойме реки
rus_verbs:растереть{}, // растереть в руке
rus_verbs:подавлять{}, // подавлять в зародыше
rus_verbs:смешиваться{}, // смешиваться в чане
инфинитив:вычитать{ вид:соверш }, глагол:вычитать{ вид:соверш }, // вычитать в книжечке
rus_verbs:сократиться{}, // сократиться в обхвате
rus_verbs:занервничать{}, // занервничать в кабинете
rus_verbs:соприкоснуться{}, // соприкоснуться в полете
rus_verbs:обозначить{}, // обозначить в объявлении
rus_verbs:обучаться{}, // обучаться в училище
rus_verbs:снизиться{}, // снизиться в нижних слоях атмосферы
rus_verbs:лелеять{}, // лелеять в сердце
rus_verbs:поддерживаться{}, // поддерживаться в суде
rus_verbs:уплыть{}, // уплыть в лодочке
rus_verbs:резвиться{}, // резвиться в саду
rus_verbs:поерзать{}, // поерзать в гамаке
rus_verbs:оплатить{}, // оплатить в ресторане
rus_verbs:похвастаться{}, // похвастаться в компании
rus_verbs:знакомиться{}, // знакомиться в классе
rus_verbs:приплыть{}, // приплыть в подводной лодке
rus_verbs:зажигать{}, // зажигать в классе
rus_verbs:смыслить{}, // смыслить в математике
rus_verbs:закопать{}, // закопать в огороде
rus_verbs:порхать{}, // порхать в зарослях
rus_verbs:потонуть{}, // потонуть в бумажках
rus_verbs:стирать{}, // стирать в холодной воде
rus_verbs:подстерегать{}, // подстерегать в придорожных кустах
rus_verbs:погулять{}, // погулять в парке
rus_verbs:предвкушать{}, // предвкушать в воображении
rus_verbs:ошеломить{}, // ошеломить в бою
rus_verbs:удостовериться{}, // удостовериться в безопасности
rus_verbs:огласить{}, // огласить в заключительной части
rus_verbs:разбогатеть{}, // разбогатеть в деревне
rus_verbs:грохотать{}, // грохотать в мастерской
rus_verbs:реализоваться{}, // реализоваться в должности
rus_verbs:красть{}, // красть в магазине
rus_verbs:нарваться{}, // нарваться в коридоре
rus_verbs:застывать{}, // застывать в неудобной позе
rus_verbs:толкаться{}, // толкаться в тесной комнате
rus_verbs:извлекать{}, // извлекать в аппарате
rus_verbs:обжигать{}, // обжигать в печи
rus_verbs:запечатлеть{}, // запечатлеть в кинохронике
rus_verbs:тренироваться{}, // тренироваться в зале
rus_verbs:поспорить{}, // поспорить в кабинете
rus_verbs:рыскать{}, // рыскать в лесу
rus_verbs:надрываться{}, // надрываться в шахте
rus_verbs:сняться{}, // сняться в фильме
rus_verbs:закружить{}, // закружить в танце
rus_verbs:затонуть{}, // затонуть в порту
rus_verbs:побыть{}, // побыть в гостях
rus_verbs:почистить{}, // почистить в носу
rus_verbs:сгорбиться{}, // сгорбиться в тесной конуре
rus_verbs:подслушивать{}, // подслушивать в классе
rus_verbs:сгорать{}, // сгорать в танке
rus_verbs:разочароваться{}, // разочароваться в артисте
инфинитив:пописать{ aux stress="поп^исать" }, глагол:пописать{ aux stress="поп^исать" }, // пописать в кустиках
rus_verbs:мять{}, // мять в руках
rus_verbs:подраться{}, // подраться в классе
rus_verbs:замести{}, // замести в прихожей
rus_verbs:откладываться{}, // откладываться в печени
rus_verbs:обозначаться{}, // обозначаться в перечне
rus_verbs:просиживать{}, // просиживать в интернете
rus_verbs:соприкасаться{}, // соприкасаться в точке
rus_verbs:начертить{}, // начертить в тетрадке
rus_verbs:уменьшать{}, // уменьшать в поперечнике
rus_verbs:тормозить{}, // тормозить в облаке
rus_verbs:затевать{}, // затевать в лаборатории
rus_verbs:затопить{}, // затопить в бухте
rus_verbs:задерживать{}, // задерживать в лифте
rus_verbs:прогуляться{}, // прогуляться в лесу
rus_verbs:прорубить{}, // прорубить во льду
rus_verbs:очищать{}, // очищать в кислоте
rus_verbs:полулежать{}, // полулежать в гамаке
rus_verbs:исправить{}, // исправить в задании
rus_verbs:предусматриваться{}, // предусматриваться в постановке задачи
rus_verbs:замучить{}, // замучить в плену
rus_verbs:разрушаться{}, // разрушаться в верхней части
rus_verbs:ерзать{}, // ерзать в кресле
rus_verbs:покопаться{}, // покопаться в залежах
rus_verbs:раскаяться{}, // раскаяться в содеянном
rus_verbs:пробежаться{}, // пробежаться в парке
rus_verbs:полежать{}, // полежать в гамаке
rus_verbs:позаимствовать{}, // позаимствовать в книге
rus_verbs:снижать{}, // снижать в несколько раз
rus_verbs:черпать{}, // черпать в поэзии
rus_verbs:заверять{}, // заверять в своей искренности
rus_verbs:проглядеть{}, // проглядеть в сумерках
rus_verbs:припарковать{}, // припарковать во дворе
rus_verbs:сверлить{}, // сверлить в стене
rus_verbs:здороваться{}, // здороваться в аудитории
rus_verbs:рожать{}, // рожать в воде
rus_verbs:нацарапать{}, // нацарапать в тетрадке
rus_verbs:затопать{}, // затопать в коридоре
rus_verbs:прописать{}, // прописать в правилах
rus_verbs:сориентироваться{}, // сориентироваться в обстоятельствах
rus_verbs:снизить{}, // снизить в несколько раз
rus_verbs:заблуждаться{}, // заблуждаться в своей теории
rus_verbs:откопать{}, // откопать в отвалах
rus_verbs:смастерить{}, // смастерить в лаборатории
rus_verbs:замедлиться{}, // замедлиться в парафине
rus_verbs:избивать{}, // избивать в участке
rus_verbs:мыться{}, // мыться в бане
rus_verbs:сварить{}, // сварить в кастрюльке
rus_verbs:раскопать{}, // раскопать в снегу
rus_verbs:крепиться{}, // крепиться в держателе
rus_verbs:дробить{}, // дробить в мельнице
rus_verbs:попить{}, // попить в ресторанчике
rus_verbs:затронуть{}, // затронуть в душе
rus_verbs:лязгнуть{}, // лязгнуть в тишине
rus_verbs:заправлять{}, // заправлять в полете
rus_verbs:размножаться{}, // размножаться в неволе
rus_verbs:потопить{}, // потопить в Тихом Океане
rus_verbs:кушать{}, // кушать в столовой
rus_verbs:замолкать{}, // замолкать в замешательстве
rus_verbs:измеряться{}, // измеряться в дюймах
rus_verbs:сбываться{}, // сбываться в мечтах
rus_verbs:задернуть{}, // задернуть в комнате
rus_verbs:затихать{}, // затихать в темноте
rus_verbs:прослеживаться{}, // прослеживается в журнале
rus_verbs:прерываться{}, // прерывается в начале
rus_verbs:изображаться{}, // изображается в любых фильмах
rus_verbs:фиксировать{}, // фиксировать в данной точке
rus_verbs:ослаблять{}, // ослаблять в поясе
rus_verbs:зреть{}, // зреть в теплице
rus_verbs:зеленеть{}, // зеленеть в огороде
rus_verbs:критиковать{}, // критиковать в статье
rus_verbs:облететь{}, // облететь в частном вертолете
rus_verbs:разбросать{}, // разбросать в комнате
rus_verbs:заразиться{}, // заразиться в людном месте
rus_verbs:рассеять{}, // рассеять в бою
rus_verbs:печься{}, // печься в духовке
rus_verbs:поспать{}, // поспать в палатке
rus_verbs:заступиться{}, // заступиться в драке
rus_verbs:сплетаться{}, // сплетаться в середине
rus_verbs:поместиться{}, // поместиться в мешке
rus_verbs:спереть{}, // спереть в лавке
// инфинитив:ликвидировать{ вид:несоверш }, глагол:ликвидировать{ вид:несоверш }, // ликвидировать в пригороде
// инфинитив:ликвидировать{ вид:соверш }, глагол:ликвидировать{ вид:соверш },
rus_verbs:проваляться{}, // проваляться в постели
rus_verbs:лечиться{}, // лечиться в стационаре
rus_verbs:определиться{}, // определиться в честном бою
rus_verbs:обработать{}, // обработать в растворе
rus_verbs:пробивать{}, // пробивать в стене
rus_verbs:перемешаться{}, // перемешаться в чане
rus_verbs:чесать{}, // чесать в паху
rus_verbs:пролечь{}, // пролечь в пустынной местности
rus_verbs:скитаться{}, // скитаться в дальних странах
rus_verbs:затрудняться{}, // затрудняться в выборе
rus_verbs:отряхнуться{}, // отряхнуться в коридоре
rus_verbs:разыгрываться{}, // разыгрываться в лотерее
rus_verbs:помолиться{}, // помолиться в церкви
rus_verbs:предписывать{}, // предписывать в рецепте
rus_verbs:порваться{}, // порваться в слабом месте
rus_verbs:греться{}, // греться в здании
rus_verbs:опровергать{}, // опровергать в своем выступлении
rus_verbs:помянуть{}, // помянуть в своем выступлении
rus_verbs:допросить{}, // допросить в прокуратуре
rus_verbs:материализоваться{}, // материализоваться в соседнем здании
rus_verbs:рассеиваться{}, // рассеиваться в воздухе
rus_verbs:перевозить{}, // перевозить в вагоне
rus_verbs:отбывать{}, // отбывать в тюрьме
rus_verbs:попахивать{}, // попахивать в отхожем месте
rus_verbs:перечислять{}, // перечислять в заключении
rus_verbs:зарождаться{}, // зарождаться в дебрях
rus_verbs:предъявлять{}, // предъявлять в своем письме
rus_verbs:распространять{}, // распространять в сети
rus_verbs:пировать{}, // пировать в соседнем селе
rus_verbs:начертать{}, // начертать в летописи
rus_verbs:расцветать{}, // расцветать в подходящих условиях
rus_verbs:царствовать{}, // царствовать в южной части материка
rus_verbs:накопить{}, // накопить в буфере
rus_verbs:закрутиться{}, // закрутиться в рутине
rus_verbs:отработать{}, // отработать в забое
rus_verbs:обокрасть{}, // обокрасть в автобусе
rus_verbs:прокладывать{}, // прокладывать в снегу
rus_verbs:ковырять{}, // ковырять в носу
rus_verbs:копить{}, // копить в очереди
rus_verbs:полечь{}, // полечь в степях
rus_verbs:щебетать{}, // щебетать в кустиках
rus_verbs:подчеркиваться{}, // подчеркиваться в сообщении
rus_verbs:посеять{}, // посеять в огороде
rus_verbs:разъезжать{}, // разъезжать в кабриолете
rus_verbs:замечаться{}, // замечаться в лесу
rus_verbs:просчитать{}, // просчитать в уме
rus_verbs:маяться{}, // маяться в командировке
rus_verbs:выхватывать{}, // выхватывать в тексте
rus_verbs:креститься{}, // креститься в деревенской часовне
rus_verbs:обрабатывать{}, // обрабатывать в растворе кислоты
rus_verbs:настигать{}, // настигать в огороде
rus_verbs:разгуливать{}, // разгуливать в роще
rus_verbs:насиловать{}, // насиловать в квартире
rus_verbs:побороть{}, // побороть в себе
rus_verbs:учитывать{}, // учитывать в расчетах
rus_verbs:искажать{}, // искажать в заметке
rus_verbs:пропить{}, // пропить в кабаке
rus_verbs:катать{}, // катать в лодочке
rus_verbs:припрятать{}, // припрятать в кармашке
rus_verbs:запаниковать{}, // запаниковать в бою
rus_verbs:рассыпать{}, // рассыпать в траве
rus_verbs:застревать{}, // застревать в ограде
rus_verbs:зажигаться{}, // зажигаться в сумерках
rus_verbs:жарить{}, // жарить в масле
rus_verbs:накапливаться{}, // накапливаться в костях
rus_verbs:распуститься{}, // распуститься в горшке
rus_verbs:проголосовать{}, // проголосовать в передвижном пункте
rus_verbs:странствовать{}, // странствовать в автомобиле
rus_verbs:осматриваться{}, // осматриваться в хоромах
rus_verbs:разворачивать{}, // разворачивать в спортзале
rus_verbs:заскучать{}, // заскучать в самолете
rus_verbs:напутать{}, // напутать в расчете
rus_verbs:перекусить{}, // перекусить в столовой
rus_verbs:спасаться{}, // спасаться в автономной капсуле
rus_verbs:посовещаться{}, // посовещаться в комнате
rus_verbs:доказываться{}, // доказываться в статье
rus_verbs:познаваться{}, // познаваться в беде
rus_verbs:загрустить{}, // загрустить в одиночестве
rus_verbs:оживить{}, // оживить в памяти
rus_verbs:переворачиваться{}, // переворачиваться в гробу
rus_verbs:заприметить{}, // заприметить в лесу
rus_verbs:отравиться{}, // отравиться в забегаловке
rus_verbs:продержать{}, // продержать в клетке
rus_verbs:выявить{}, // выявить в костях
rus_verbs:заседать{}, // заседать в совете
rus_verbs:расплачиваться{}, // расплачиваться в первой кассе
rus_verbs:проломить{}, // проломить в двери
rus_verbs:подражать{}, // подражать в мелочах
rus_verbs:подсчитывать{}, // подсчитывать в уме
rus_verbs:опережать{}, // опережать во всем
rus_verbs:сформироваться{}, // сформироваться в облаке
rus_verbs:укрепиться{}, // укрепиться в мнении
rus_verbs:отстоять{}, // отстоять в очереди
rus_verbs:развертываться{}, // развертываться в месте испытания
rus_verbs:замерзать{}, // замерзать во льду
rus_verbs:утопать{}, // утопать в снегу
rus_verbs:раскаиваться{}, // раскаиваться в содеянном
rus_verbs:организовывать{}, // организовывать в пионерлагере
rus_verbs:перевестись{}, // перевестись в наших краях
rus_verbs:смешивать{}, // смешивать в блендере
rus_verbs:ютиться{}, // ютиться в тесной каморке
rus_verbs:прождать{}, // прождать в аудитории
rus_verbs:подыскивать{}, // подыскивать в женском общежитии
rus_verbs:замочить{}, // замочить в сортире
rus_verbs:мерзнуть{}, // мерзнуть в тонкой курточке
rus_verbs:растирать{}, // растирать в ступке
rus_verbs:замедлять{}, // замедлять в парафине
rus_verbs:переспать{}, // переспать в палатке
rus_verbs:рассекать{}, // рассекать в кабриолете
rus_verbs:отыскивать{}, // отыскивать в залежах
rus_verbs:опровергнуть{}, // опровергнуть в своем выступлении
rus_verbs:дрыхнуть{}, // дрыхнуть в гамаке
rus_verbs:укрываться{}, // укрываться в землянке
rus_verbs:запечься{}, // запечься в золе
rus_verbs:догорать{}, // догорать в темноте
rus_verbs:застилать{}, // застилать в коридоре
rus_verbs:сыскаться{}, // сыскаться в деревне
rus_verbs:переделать{}, // переделать в мастерской
rus_verbs:разъяснять{}, // разъяснять в своей лекции
rus_verbs:селиться{}, // селиться в центре
rus_verbs:оплачивать{}, // оплачивать в магазине
rus_verbs:переворачивать{}, // переворачивать в закрытой банке
rus_verbs:упражняться{}, // упражняться в остроумии
rus_verbs:пометить{}, // пометить в списке
rus_verbs:припомниться{}, // припомниться в завещании
rus_verbs:приютить{}, // приютить в амбаре
rus_verbs:натерпеться{}, // натерпеться в темнице
rus_verbs:затеваться{}, // затеваться в клубе
rus_verbs:уплывать{}, // уплывать в лодке
rus_verbs:скиснуть{}, // скиснуть в бидоне
rus_verbs:заколоть{}, // заколоть в боку
rus_verbs:замерцать{}, // замерцать в темноте
rus_verbs:фиксироваться{}, // фиксироваться в протоколе
rus_verbs:запираться{}, // запираться в комнате
rus_verbs:съезжаться{}, // съезжаться в каретах
rus_verbs:толочься{}, // толочься в ступе
rus_verbs:потанцевать{}, // потанцевать в клубе
rus_verbs:побродить{}, // побродить в парке
rus_verbs:назревать{}, // назревать в коллективе
rus_verbs:дохнуть{}, // дохнуть в питомнике
rus_verbs:крестить{}, // крестить в деревенской церквушке
rus_verbs:рассчитаться{}, // рассчитаться в банке
rus_verbs:припарковаться{}, // припарковаться во дворе
rus_verbs:отхватить{}, // отхватить в магазинчике
rus_verbs:остывать{}, // остывать в холодильнике
rus_verbs:составляться{}, // составляться в атмосфере тайны
rus_verbs:переваривать{}, // переваривать в тишине
rus_verbs:хвастать{}, // хвастать в казино
rus_verbs:отрабатывать{}, // отрабатывать в теплице
rus_verbs:разлечься{}, // разлечься в кровати
rus_verbs:прокручивать{}, // прокручивать в голове
rus_verbs:очертить{}, // очертить в воздухе
rus_verbs:сконфузиться{}, // сконфузиться в окружении незнакомых людей
rus_verbs:выявлять{}, // выявлять в боевых условиях
rus_verbs:караулить{}, // караулить в лифте
rus_verbs:расставлять{}, // расставлять в бойницах
rus_verbs:прокрутить{}, // прокрутить в голове
rus_verbs:пересказывать{}, // пересказывать в первой главе
rus_verbs:задавить{}, // задавить в зародыше
rus_verbs:хозяйничать{}, // хозяйничать в холодильнике
rus_verbs:хвалиться{}, // хвалиться в детском садике
rus_verbs:оперировать{}, // оперировать в полевом госпитале
rus_verbs:формулировать{}, // формулировать в следующей главе
rus_verbs:застигнуть{}, // застигнуть в неприглядном виде
rus_verbs:замурлыкать{}, // замурлыкать в тепле
rus_verbs:поддакивать{}, // поддакивать в споре
rus_verbs:прочертить{}, // прочертить в воздухе
rus_verbs:отменять{}, // отменять в городе коменданский час
rus_verbs:колдовать{}, // колдовать в лаборатории
rus_verbs:отвозить{}, // отвозить в машине
rus_verbs:трахать{}, // трахать в гамаке
rus_verbs:повозиться{}, // повозиться в мешке
rus_verbs:ремонтировать{}, // ремонтировать в центре
rus_verbs:робеть{}, // робеть в гостях
rus_verbs:перепробовать{}, // перепробовать в деле
инфинитив:реализовать{ вид:соверш }, инфинитив:реализовать{ вид:несоверш }, // реализовать в новой версии
глагол:реализовать{ вид:соверш }, глагол:реализовать{ вид:несоверш },
rus_verbs:покаяться{}, // покаяться в церкви
rus_verbs:попрыгать{}, // попрыгать в бассейне
rus_verbs:умалчивать{}, // умалчивать в своем докладе
rus_verbs:ковыряться{}, // ковыряться в старой технике
rus_verbs:расписывать{}, // расписывать в деталях
rus_verbs:вязнуть{}, // вязнуть в песке
rus_verbs:погрязнуть{}, // погрязнуть в скандалах
rus_verbs:корениться{}, // корениться в неспособности выполнить поставленную задачу
rus_verbs:зажимать{}, // зажимать в углу
rus_verbs:стискивать{}, // стискивать в ладонях
rus_verbs:практиковаться{}, // практиковаться в приготовлении соуса
rus_verbs:израсходовать{}, // израсходовать в полете
rus_verbs:клокотать{}, // клокотать в жерле
rus_verbs:обвиняться{}, // обвиняться в растрате
rus_verbs:уединиться{}, // уединиться в кладовке
rus_verbs:подохнуть{}, // подохнуть в болоте
rus_verbs:кипятиться{}, // кипятиться в чайнике
rus_verbs:уродиться{}, // уродиться в лесу
rus_verbs:продолжиться{}, // продолжиться в баре
rus_verbs:расшифровать{}, // расшифровать в специальном устройстве
rus_verbs:посапывать{}, // посапывать в кровати
rus_verbs:скрючиться{}, // скрючиться в мешке
rus_verbs:лютовать{}, // лютовать в отдаленных селах
rus_verbs:расписать{}, // расписать в статье
rus_verbs:публиковаться{}, // публиковаться в научном журнале
rus_verbs:зарегистрировать{}, // зарегистрировать в комитете
rus_verbs:прожечь{}, // прожечь в листе
rus_verbs:переждать{}, // переждать в окопе
rus_verbs:публиковать{}, // публиковать в журнале
rus_verbs:морщить{}, // морщить в уголках глаз
rus_verbs:спиться{}, // спиться в одиночестве
rus_verbs:изведать{}, // изведать в гареме
rus_verbs:обмануться{}, // обмануться в ожиданиях
rus_verbs:сочетать{}, // сочетать в себе
rus_verbs:подрабатывать{}, // подрабатывать в магазине
rus_verbs:репетировать{}, // репетировать в студии
rus_verbs:рябить{}, // рябить в глазах
rus_verbs:намочить{}, // намочить в луже
rus_verbs:скатать{}, // скатать в руке
rus_verbs:одевать{}, // одевать в магазине
rus_verbs:испечь{}, // испечь в духовке
rus_verbs:сбрить{}, // сбрить в подмышках
rus_verbs:зажужжать{}, // зажужжать в ухе
rus_verbs:сберечь{}, // сберечь в тайном месте
rus_verbs:согреться{}, // согреться в хижине
инфинитив:дебютировать{ вид:несоверш }, инфинитив:дебютировать{ вид:соверш }, // дебютировать в спектакле
глагол:дебютировать{ вид:несоверш }, глагол:дебютировать{ вид:соверш },
rus_verbs:переплыть{}, // переплыть в лодочке
rus_verbs:передохнуть{}, // передохнуть в тени
rus_verbs:отсвечивать{}, // отсвечивать в зеркалах
rus_verbs:переправляться{}, // переправляться в лодках
rus_verbs:накупить{}, // накупить в магазине
rus_verbs:проторчать{}, // проторчать в очереди
rus_verbs:проскальзывать{}, // проскальзывать в сообщениях
rus_verbs:застукать{}, // застукать в солярии
rus_verbs:наесть{}, // наесть в отпуске
rus_verbs:подвизаться{}, // подвизаться в новом деле
rus_verbs:вычистить{}, // вычистить в саду
rus_verbs:кормиться{}, // кормиться в лесу
rus_verbs:покурить{}, // покурить в саду
rus_verbs:понизиться{}, // понизиться в ранге
rus_verbs:зимовать{}, // зимовать в избушке
rus_verbs:проверяться{}, // проверяться в службе безопасности
rus_verbs:подпирать{}, // подпирать в первом забое
rus_verbs:кувыркаться{}, // кувыркаться в постели
rus_verbs:похрапывать{}, // похрапывать в постели
rus_verbs:завязнуть{}, // завязнуть в песке
rus_verbs:трактовать{}, // трактовать в исследовательской статье
rus_verbs:замедляться{}, // замедляться в тяжелой воде
rus_verbs:шастать{}, // шастать в здании
rus_verbs:заночевать{}, // заночевать в пути
rus_verbs:наметиться{}, // наметиться в исследованиях рака
rus_verbs:освежить{}, // освежить в памяти
rus_verbs:оспаривать{}, // оспаривать в суде
rus_verbs:умещаться{}, // умещаться в ячейке
rus_verbs:искупить{}, // искупить в бою
rus_verbs:отсиживаться{}, // отсиживаться в тылу
rus_verbs:мчать{}, // мчать в кабриолете
rus_verbs:обличать{}, // обличать в своем выступлении
rus_verbs:сгнить{}, // сгнить в тюряге
rus_verbs:опробовать{}, // опробовать в деле
rus_verbs:тренировать{}, // тренировать в зале
rus_verbs:прославить{}, // прославить в академии
rus_verbs:учитываться{}, // учитываться в дипломной работе
rus_verbs:повеселиться{}, // повеселиться в лагере
rus_verbs:поумнеть{}, // поумнеть в карцере
rus_verbs:перестрелять{}, // перестрелять в воздухе
rus_verbs:проведать{}, // проведать в больнице
rus_verbs:измучиться{}, // измучиться в деревне
rus_verbs:прощупать{}, // прощупать в глубине
rus_verbs:изготовлять{}, // изготовлять в сарае
rus_verbs:свирепствовать{}, // свирепствовать в популяции
rus_verbs:иссякать{}, // иссякать в источнике
rus_verbs:гнездиться{}, // гнездиться в дупле
rus_verbs:разогнаться{}, // разогнаться в спортивной машине
rus_verbs:опознавать{}, // опознавать в неизвестном
rus_verbs:засвидетельствовать{}, // засвидетельствовать в суде
rus_verbs:сконцентрировать{}, // сконцентрировать в своих руках
rus_verbs:редактировать{}, // редактировать в редакторе
rus_verbs:покупаться{}, // покупаться в магазине
rus_verbs:промышлять{}, // промышлять в роще
rus_verbs:растягиваться{}, // растягиваться в коридоре
rus_verbs:приобретаться{}, // приобретаться в антикварных лавках
инфинитив:подрезать{ вид:несоверш }, инфинитив:подрезать{ вид:соверш }, // подрезать в воде
глагол:подрезать{ вид:несоверш }, глагол:подрезать{ вид:соверш },
rus_verbs:запечатлеться{}, // запечатлеться в мозгу
rus_verbs:укрывать{}, // укрывать в подвале
rus_verbs:закрепиться{}, // закрепиться в первой башне
rus_verbs:освежать{}, // освежать в памяти
rus_verbs:громыхать{}, // громыхать в ванной
инфинитив:подвигаться{ вид:соверш }, инфинитив:подвигаться{ вид:несоверш }, // подвигаться в кровати
глагол:подвигаться{ вид:соверш }, глагол:подвигаться{ вид:несоверш },
rus_verbs:добываться{}, // добываться в шахтах
rus_verbs:растворить{}, // растворить в кислоте
rus_verbs:приплясывать{}, // приплясывать в гримерке
rus_verbs:доживать{}, // доживать в доме престарелых
rus_verbs:отпраздновать{}, // отпраздновать в ресторане
rus_verbs:сотрясаться{}, // сотрясаться в конвульсиях
rus_verbs:помыть{}, // помыть в проточной воде
инфинитив:увязать{ вид:несоверш }, инфинитив:увязать{ вид:соверш }, // увязать в песке
глагол:увязать{ вид:несоверш }, глагол:увязать{ вид:соверш },
прилагательное:увязавший{ вид:несоверш },
rus_verbs:наличествовать{}, // наличествовать в запаснике
rus_verbs:нащупывать{}, // нащупывать в кармане
rus_verbs:повествоваться{}, // повествоваться в рассказе
rus_verbs:отремонтировать{}, // отремонтировать в техцентре
rus_verbs:покалывать{}, // покалывать в правом боку
rus_verbs:сиживать{}, // сиживать в саду
rus_verbs:разрабатываться{}, // разрабатываться в секретных лабораториях
rus_verbs:укрепляться{}, // укрепляться в мнении
rus_verbs:разниться{}, // разниться во взглядах
rus_verbs:сполоснуть{}, // сполоснуть в водичке
rus_verbs:скупать{}, // скупать в магазине
rus_verbs:почесывать{}, // почесывать в паху
rus_verbs:оформлять{}, // оформлять в конторе
rus_verbs:распускаться{}, // распускаться в садах
rus_verbs:зарябить{}, // зарябить в глазах
rus_verbs:загореть{}, // загореть в Испании
rus_verbs:очищаться{}, // очищаться в баке
rus_verbs:остудить{}, // остудить в холодной воде
rus_verbs:разбомбить{}, // разбомбить в горах
rus_verbs:издохнуть{}, // издохнуть в бедности
rus_verbs:проехаться{}, // проехаться в новой машине
rus_verbs:задействовать{}, // задействовать в анализе
rus_verbs:произрастать{}, // произрастать в степи
rus_verbs:разуться{}, // разуться в прихожей
rus_verbs:сооружать{}, // сооружать в огороде
rus_verbs:зачитывать{}, // зачитывать в суде
rus_verbs:состязаться{}, // состязаться в остроумии
rus_verbs:ополоснуть{}, // ополоснуть в молоке
rus_verbs:уместиться{}, // уместиться в кармане
rus_verbs:совершенствоваться{}, // совершенствоваться в управлении мотоциклом
rus_verbs:стираться{}, // стираться в стиральной машине
rus_verbs:искупаться{}, // искупаться в прохладной реке
rus_verbs:курировать{}, // курировать в правительстве
rus_verbs:закупить{}, // закупить в магазине
rus_verbs:плодиться{}, // плодиться в подходящих условиях
rus_verbs:горланить{}, // горланить в парке
rus_verbs:першить{}, // першить в горле
rus_verbs:пригрезиться{}, // пригрезиться во сне
rus_verbs:исправлять{}, // исправлять в тетрадке
rus_verbs:расслабляться{}, // расслабляться в гамаке
rus_verbs:скапливаться{}, // скапливаться в нижней части
rus_verbs:сплетничать{}, // сплетничают в комнате
rus_verbs:раздевать{}, // раздевать в кабинке
rus_verbs:окопаться{}, // окопаться в лесу
rus_verbs:загорать{}, // загорать в Испании
rus_verbs:подпевать{}, // подпевать в церковном хоре
rus_verbs:прожужжать{}, // прожужжать в динамике
rus_verbs:изучаться{}, // изучаться в дикой природе
rus_verbs:заклубиться{}, // заклубиться в воздухе
rus_verbs:подметать{}, // подметать в зале
rus_verbs:подозреваться{}, // подозреваться в совершении кражи
rus_verbs:обогащать{}, // обогащать в специальном аппарате
rus_verbs:издаться{}, // издаться в другом издательстве
rus_verbs:справить{}, // справить в кустах нужду
rus_verbs:помыться{}, // помыться в бане
rus_verbs:проскакивать{}, // проскакивать в словах
rus_verbs:попивать{}, // попивать в кафе чай
rus_verbs:оформляться{}, // оформляться в регистратуре
rus_verbs:чирикать{}, // чирикать в кустах
rus_verbs:скупить{}, // скупить в магазинах
rus_verbs:переночевать{}, // переночевать в гостинице
rus_verbs:концентрироваться{}, // концентрироваться в пробирке
rus_verbs:одичать{}, // одичать в лесу
rus_verbs:ковырнуть{}, // ковырнуть в ухе
rus_verbs:затеплиться{}, // затеплиться в глубине души
rus_verbs:разгрести{}, // разгрести в задачах залежи
rus_verbs:застопориться{}, // застопориться в начале списка
rus_verbs:перечисляться{}, // перечисляться во введении
rus_verbs:покататься{}, // покататься в парке аттракционов
rus_verbs:изловить{}, // изловить в поле
rus_verbs:прославлять{}, // прославлять в стихах
rus_verbs:промочить{}, // промочить в луже
rus_verbs:поделывать{}, // поделывать в отпуске
rus_verbs:просуществовать{}, // просуществовать в первобытном состоянии
rus_verbs:подстеречь{}, // подстеречь в подъезде
rus_verbs:прикупить{}, // прикупить в магазине
rus_verbs:перемешивать{}, // перемешивать в кастрюле
rus_verbs:тискать{}, // тискать в углу
rus_verbs:купать{}, // купать в теплой водичке
rus_verbs:завариться{}, // завариться в стакане
rus_verbs:притулиться{}, // притулиться в углу
rus_verbs:пострелять{}, // пострелять в тире
rus_verbs:навесить{}, // навесить в больнице
инфинитив:изолировать{ вид:соверш }, инфинитив:изолировать{ вид:несоверш }, // изолировать в камере
глагол:изолировать{ вид:соверш }, глагол:изолировать{ вид:несоверш },
rus_verbs:нежиться{}, // нежится в постельке
rus_verbs:притомиться{}, // притомиться в школе
rus_verbs:раздвоиться{}, // раздвоиться в глазах
rus_verbs:навалить{}, // навалить в углу
rus_verbs:замуровать{}, // замуровать в склепе
rus_verbs:поселяться{}, // поселяться в кроне дуба
rus_verbs:потягиваться{}, // потягиваться в кровати
rus_verbs:укачать{}, // укачать в поезде
rus_verbs:отлеживаться{}, // отлеживаться в гамаке
rus_verbs:разменять{}, // разменять в кассе
rus_verbs:прополоскать{}, // прополоскать в чистой теплой воде
rus_verbs:ржаветь{}, // ржаветь в воде
rus_verbs:уличить{}, // уличить в плагиате
rus_verbs:мутиться{}, // мутиться в голове
rus_verbs:растворять{}, // растворять в бензоле
rus_verbs:двоиться{}, // двоиться в глазах
rus_verbs:оговорить{}, // оговорить в договоре
rus_verbs:подделать{}, // подделать в документе
rus_verbs:зарегистрироваться{}, // зарегистрироваться в социальной сети
rus_verbs:растолстеть{}, // растолстеть в талии
rus_verbs:повоевать{}, // повоевать в городских условиях
rus_verbs:прибраться{}, // гнушаться прибраться в хлеву
rus_verbs:поглощаться{}, // поглощаться в металлической фольге
rus_verbs:ухать{}, // ухать в лесу
rus_verbs:подписываться{}, // подписываться в петиции
rus_verbs:покатать{}, // покатать в машинке
rus_verbs:излечиться{}, // излечиться в клинике
rus_verbs:трепыхаться{}, // трепыхаться в мешке
rus_verbs:кипятить{}, // кипятить в кастрюле
rus_verbs:понастроить{}, // понастроить в прибрежной зоне
rus_verbs:перебывать{}, // перебывать во всех европейских столицах
rus_verbs:оглашать{}, // оглашать в итоговой части
rus_verbs:преуспевать{}, // преуспевать в новом бизнесе
rus_verbs:консультироваться{}, // консультироваться в техподдержке
rus_verbs:накапливать{}, // накапливать в печени
rus_verbs:перемешать{}, // перемешать в контейнере
rus_verbs:наследить{}, // наследить в коридоре
rus_verbs:выявиться{}, // выявиться в результе
rus_verbs:забулькать{}, // забулькать в болоте
rus_verbs:отваривать{}, // отваривать в молоке
rus_verbs:запутываться{}, // запутываться в веревках
rus_verbs:нагреться{}, // нагреться в микроволновой печке
rus_verbs:рыбачить{}, // рыбачить в открытом море
rus_verbs:укорениться{}, // укорениться в сознании широких народных масс
rus_verbs:умывать{}, // умывать в тазике
rus_verbs:защекотать{}, // защекотать в носу
rus_verbs:заходиться{}, // заходиться в плаче
инфинитив:искупать{ вид:соверш }, инфинитив:искупать{ вид:несоверш }, // искупать в прохладной водичке
глагол:искупать{ вид:соверш }, глагол:искупать{ вид:несоверш },
деепричастие:искупав{}, деепричастие:искупая{},
rus_verbs:заморозить{}, // заморозить в холодильнике
rus_verbs:закреплять{}, // закреплять в металлическом держателе
rus_verbs:расхватать{}, // расхватать в магазине
rus_verbs:истязать{}, // истязать в тюремном подвале
rus_verbs:заржаветь{}, // заржаветь во влажной атмосфере
rus_verbs:обжаривать{}, // обжаривать в подсолнечном масле
rus_verbs:умереть{}, // Ты, подлый предатель, умрешь в нищете
rus_verbs:подогреть{}, // подогрей в микроволновке
rus_verbs:подогревать{},
rus_verbs:затянуть{}, // Кузнечики, сверчки, скрипачи и медведки затянули в траве свою трескучую музыку
rus_verbs:проделать{}, // проделать в стене дыру
инфинитив:жениться{ вид:соверш }, // жениться в Техасе
инфинитив:жениться{ вид:несоверш },
глагол:жениться{ вид:соверш },
глагол:жениться{ вид:несоверш },
деепричастие:женившись{},
деепричастие:женясь{},
прилагательное:женатый{},
прилагательное:женившийся{вид:соверш},
прилагательное:женящийся{},
rus_verbs:всхрапнуть{}, // всхрапнуть во сне
rus_verbs:всхрапывать{}, // всхрапывать во сне
rus_verbs:ворочаться{}, // Собака ворочается во сне
rus_verbs:воссоздаваться{}, // воссоздаваться в памяти
rus_verbs:акклиматизироваться{}, // альпинисты готовятся акклиматизироваться в горах
инфинитив:атаковать{ вид:несоверш }, // взвод был атакован в лесу
инфинитив:атаковать{ вид:соверш },
глагол:атаковать{ вид:несоверш },
глагол:атаковать{ вид:соверш },
прилагательное:атакованный{},
прилагательное:атаковавший{},
прилагательное:атакующий{},
инфинитив:аккумулировать{вид:несоверш}, // энергия была аккумулирована в печени
инфинитив:аккумулировать{вид:соверш},
глагол:аккумулировать{вид:несоверш},
глагол:аккумулировать{вид:соверш},
прилагательное:аккумулированный{},
прилагательное:аккумулирующий{},
//прилагательное:аккумулировавший{ вид:несоверш },
прилагательное:аккумулировавший{ вид:соверш },
rus_verbs:врисовывать{}, // врисовывать нового персонажа в анимацию
rus_verbs:вырасти{}, // Он вырос в глазах коллег.
rus_verbs:иметь{}, // Он всегда имел в резерве острое словцо.
rus_verbs:убить{}, // убить в себе зверя
инфинитив:абсорбироваться{ вид:соверш }, // жидкость абсорбируется в поглощающей ткани
инфинитив:абсорбироваться{ вид:несоверш },
глагол:абсорбироваться{ вид:соверш },
глагол:абсорбироваться{ вид:несоверш },
rus_verbs:поставить{}, // поставить в углу
rus_verbs:сжимать{}, // сжимать в кулаке
rus_verbs:готовиться{}, // альпинисты готовятся акклиматизироваться в горах
rus_verbs:аккумулироваться{}, // энергия аккумулируется в жировых отложениях
инфинитив:активизироваться{ вид:несоверш }, // в горах активизировались повстанцы
инфинитив:активизироваться{ вид:соверш },
глагол:активизироваться{ вид:несоверш },
глагол:активизироваться{ вид:соверш },
rus_verbs:апробировать{}, // пилот апробировал в ходе испытаний новый режим планера
rus_verbs:арестовать{}, // наркодилер был арестован в помещении кафе
rus_verbs:базировать{}, // установка будет базирована в лесу
rus_verbs:барахтаться{}, // дети барахтались в воде
rus_verbs:баррикадироваться{}, // преступники баррикадируются в помещении банка
rus_verbs:барствовать{}, // Семен Семенович барствовал в своей деревне
rus_verbs:бесчинствовать{}, // Боевики бесчинствовали в захваченном селе
rus_verbs:блаженствовать{}, // Воробьи блаженствовали в кроне рябины
rus_verbs:блуждать{}, // Туристы блуждали в лесу
rus_verbs:брать{}, // Жена берет деньги в тумбочке
rus_verbs:бродить{}, // парочки бродили в парке
rus_verbs:обойти{}, // Бразилия обошла Россию в рейтинге
rus_verbs:задержать{}, // Знаменитый советский фигурист задержан в США
rus_verbs:бултыхаться{}, // Ноги бултыхаются в воде
rus_verbs:вариться{}, // Курица варится в кастрюле
rus_verbs:закончиться{}, // Эта рецессия закончилась в 2003 году
rus_verbs:прокручиваться{}, // Ключ прокручивается в замке
rus_verbs:прокрутиться{}, // Ключ трижды прокрутился в замке
rus_verbs:храниться{}, // Настройки хранятся в текстовом файле
rus_verbs:сохраняться{}, // Настройки сохраняются в текстовом файле
rus_verbs:витать{}, // Мальчик витает в облаках
rus_verbs:владычествовать{}, // Король владычествует в стране
rus_verbs:властвовать{}, // Олигархи властвовали в стране
rus_verbs:возбудить{}, // возбудить в сердце тоску
rus_verbs:возбуждать{}, // возбуждать в сердце тоску
rus_verbs:возвыситься{}, // возвыситься в глазах современников
rus_verbs:возжечь{}, // возжечь в храме огонь
rus_verbs:возжечься{}, // Огонь возжёгся в храме
rus_verbs:возжигать{}, // возжигать в храме огонь
rus_verbs:возжигаться{}, // Огонь возжигается в храме
rus_verbs:вознамериваться{}, // вознамериваться уйти в монастырь
rus_verbs:вознамериться{}, // вознамериться уйти в монастырь
rus_verbs:возникать{}, // Новые идеи неожиданно возникают в колиной голове
rus_verbs:возникнуть{}, // Новые идейки возникли в голове
rus_verbs:возродиться{}, // возродиться в новом качестве
rus_verbs:возрождать{}, // возрождать в новом качестве
rus_verbs:возрождаться{}, // возрождаться в новом амплуа
rus_verbs:ворошить{}, // ворошить в камине кочергой золу
rus_verbs:воспевать{}, // Поэты воспевают героев в одах
rus_verbs:воспеваться{}, // Герои воспеваются в одах поэтами
rus_verbs:воспеть{}, // Поэты воспели в этой оде героев
rus_verbs:воспретить{}, // воспретить в помещении азартные игры
rus_verbs:восславить{}, // Поэты восславили в одах
rus_verbs:восславлять{}, // Поэты восславляют в одах
rus_verbs:восславляться{}, // Героя восславляются в одах
rus_verbs:воссоздать{}, // воссоздает в памяти образ человека
rus_verbs:воссоздавать{}, // воссоздать в памяти образ человека
rus_verbs:воссоздаться{}, // воссоздаться в памяти
rus_verbs:вскипятить{}, // вскипятить в чайнике воду
rus_verbs:вскипятиться{}, // вскипятиться в чайнике
rus_verbs:встретить{}, // встретить в классе старого приятеля
rus_verbs:встретиться{}, // встретиться в классе
rus_verbs:встречать{}, // встречать в лесу голодного медведя
rus_verbs:встречаться{}, // встречаться в кафе
rus_verbs:выбривать{}, // выбривать что-то в подмышках
rus_verbs:выбрить{}, // выбрить что-то в паху
rus_verbs:вывалять{}, // вывалять кого-то в грязи
rus_verbs:вываляться{}, // вываляться в грязи
rus_verbs:вываривать{}, // вываривать в молоке
rus_verbs:вывариваться{}, // вывариваться в молоке
rus_verbs:выварить{}, // выварить в молоке
rus_verbs:вывариться{}, // вывариться в молоке
rus_verbs:выгрызать{}, // выгрызать в сыре отверствие
rus_verbs:выгрызть{}, // выгрызть в сыре отверстие
rus_verbs:выгуливать{}, // выгуливать в парке собаку
rus_verbs:выгулять{}, // выгулять в парке собаку
rus_verbs:выдолбить{}, // выдолбить в стволе углубление
rus_verbs:выжить{}, // выжить в пустыне
rus_verbs:Выискать{}, // Выискать в программе ошибку
rus_verbs:выискаться{}, // Ошибка выискалась в программе
rus_verbs:выискивать{}, // выискивать в программе ошибку
rus_verbs:выискиваться{}, // выискиваться в программе
rus_verbs:выкраивать{}, // выкраивать в расписании время
rus_verbs:выкраиваться{}, // выкраиваться в расписании
инфинитив:выкупаться{aux stress="в^ыкупаться"}, // выкупаться в озере
глагол:выкупаться{вид:соверш},
rus_verbs:выловить{}, // выловить в пруду
rus_verbs:вымачивать{}, // вымачивать в молоке
rus_verbs:вымачиваться{}, // вымачиваться в молоке
rus_verbs:вынюхивать{}, // вынюхивать в траве следы
rus_verbs:выпачкать{}, // выпачкать в смоле свою одежду
rus_verbs:выпачкаться{}, // выпачкаться в грязи
rus_verbs:вырастить{}, // вырастить в теплице ведро огурчиков
rus_verbs:выращивать{}, // выращивать в теплице помидоры
rus_verbs:выращиваться{}, // выращиваться в теплице
rus_verbs:вырыть{}, // вырыть в земле глубокую яму
rus_verbs:высадить{}, // высадить в пустынной местности
rus_verbs:высадиться{}, // высадиться в пустынной местности
rus_verbs:высаживать{}, // высаживать в пустыне
rus_verbs:высверливать{}, // высверливать в доске отверствие
rus_verbs:высверливаться{}, // высверливаться в стене
rus_verbs:высверлить{}, // высверлить в стене отверствие
rus_verbs:высверлиться{}, // высверлиться в стене
rus_verbs:выскоблить{}, // выскоблить в столешнице канавку
rus_verbs:высматривать{}, // высматривать в темноте
rus_verbs:заметить{}, // заметить в помещении
rus_verbs:оказаться{}, // оказаться в первых рядах
rus_verbs:душить{}, // душить в объятиях
rus_verbs:оставаться{}, // оставаться в классе
rus_verbs:появиться{}, // впервые появиться в фильме
rus_verbs:лежать{}, // лежать в футляре
rus_verbs:раздаться{}, // раздаться в плечах
rus_verbs:ждать{}, // ждать в здании вокзала
rus_verbs:жить{}, // жить в трущобах
rus_verbs:постелить{}, // постелить в прихожей
rus_verbs:оказываться{}, // оказываться в неприятной ситуации
rus_verbs:держать{}, // держать в голове
rus_verbs:обнаружить{}, // обнаружить в себе способность
rus_verbs:начинать{}, // начинать в лаборатории
rus_verbs:рассказывать{}, // рассказывать в лицах
rus_verbs:ожидать{}, // ожидать в помещении
rus_verbs:продолжить{}, // продолжить в помещении
rus_verbs:состоять{}, // состоять в группе
rus_verbs:родиться{}, // родиться в рубашке
rus_verbs:искать{}, // искать в кармане
rus_verbs:иметься{}, // иметься в наличии
rus_verbs:говориться{}, // говориться в среде панков
rus_verbs:клясться{}, // клясться в верности
rus_verbs:узнавать{}, // узнавать в нем своего сына
rus_verbs:признаться{}, // признаться в ошибке
rus_verbs:сомневаться{}, // сомневаться в искренности
rus_verbs:толочь{}, // толочь в ступе
rus_verbs:понадобиться{}, // понадобиться в суде
rus_verbs:служить{}, // служить в пехоте
rus_verbs:потолочь{}, // потолочь в ступе
rus_verbs:появляться{}, // появляться в театре
rus_verbs:сжать{}, // сжать в объятиях
rus_verbs:действовать{}, // действовать в постановке
rus_verbs:селить{}, // селить в гостинице
rus_verbs:поймать{}, // поймать в лесу
rus_verbs:увидать{}, // увидать в толпе
rus_verbs:подождать{}, // подождать в кабинете
rus_verbs:прочесть{}, // прочесть в глазах
rus_verbs:тонуть{}, // тонуть в реке
rus_verbs:ощущать{}, // ощущать в животе
rus_verbs:ошибиться{}, // ошибиться в расчетах
rus_verbs:отметить{}, // отметить в списке
rus_verbs:показывать{}, // показывать в динамике
rus_verbs:скрыться{}, // скрыться в траве
rus_verbs:убедиться{}, // убедиться в корректности
rus_verbs:прозвучать{}, // прозвучать в наушниках
rus_verbs:разговаривать{}, // разговаривать в фойе
rus_verbs:издать{}, // издать в России
rus_verbs:прочитать{}, // прочитать в газете
rus_verbs:попробовать{}, // попробовать в деле
rus_verbs:замечать{}, // замечать в программе ошибку
rus_verbs:нести{}, // нести в руках
rus_verbs:пропасть{}, // пропасть в плену
rus_verbs:носить{}, // носить в кармане
rus_verbs:гореть{}, // гореть в аду
rus_verbs:поправить{}, // поправить в программе
rus_verbs:застыть{}, // застыть в неудобной позе
rus_verbs:получать{}, // получать в кассе
rus_verbs:потребоваться{}, // потребоваться в работе
rus_verbs:спрятать{}, // спрятать в шкафу
rus_verbs:учиться{}, // учиться в институте
rus_verbs:развернуться{}, // развернуться в коридоре
rus_verbs:подозревать{}, // подозревать в мошенничестве
rus_verbs:играть{}, // играть в команде
rus_verbs:сыграть{}, // сыграть в команде
rus_verbs:строить{}, // строить в деревне
rus_verbs:устроить{}, // устроить в доме вечеринку
rus_verbs:находить{}, // находить в лесу
rus_verbs:нуждаться{}, // нуждаться в деньгах
rus_verbs:испытать{}, // испытать в рабочей обстановке
rus_verbs:мелькнуть{}, // мелькнуть в прицеле
rus_verbs:очутиться{}, // очутиться в закрытом помещении
инфинитив:использовать{вид:соверш}, // использовать в работе
инфинитив:использовать{вид:несоверш},
глагол:использовать{вид:несоверш},
глагол:использовать{вид:соверш},
rus_verbs:лететь{}, // лететь в самолете
rus_verbs:смеяться{}, // смеяться в цирке
rus_verbs:ездить{}, // ездить в лимузине
rus_verbs:заснуть{}, // заснуть в неудобной позе
rus_verbs:застать{}, // застать в неформальной обстановке
rus_verbs:очнуться{}, // очнуться в незнакомой обстановке
rus_verbs:твориться{}, // Что творится в закрытой зоне
rus_verbs:разглядеть{}, // разглядеть в темноте
rus_verbs:изучать{}, // изучать в естественных условиях
rus_verbs:удержаться{}, // удержаться в седле
rus_verbs:побывать{}, // побывать в зоопарке
rus_verbs:уловить{}, // уловить в словах нотку отчаяния
rus_verbs:приобрести{}, // приобрести в лавке
rus_verbs:исчезать{}, // исчезать в тумане
rus_verbs:уверять{}, // уверять в своей невиновности
rus_verbs:продолжаться{}, // продолжаться в воздухе
rus_verbs:открывать{}, // открывать в городе новый стадион
rus_verbs:поддержать{}, // поддержать в парке порядок
rus_verbs:солить{}, // солить в бочке
rus_verbs:прожить{}, // прожить в деревне
rus_verbs:создавать{}, // создавать в театре
rus_verbs:обсуждать{}, // обсуждать в коллективе
rus_verbs:заказать{}, // заказать в магазине
rus_verbs:отыскать{}, // отыскать в гараже
rus_verbs:уснуть{}, // уснуть в кресле
rus_verbs:задержаться{}, // задержаться в театре
rus_verbs:подобрать{}, // подобрать в коллекции
rus_verbs:пробовать{}, // пробовать в работе
rus_verbs:курить{}, // курить в закрытом помещении
rus_verbs:устраивать{}, // устраивать в лесу засаду
rus_verbs:установить{}, // установить в багажнике
rus_verbs:запереть{}, // запереть в сарае
rus_verbs:содержать{}, // содержать в достатке
rus_verbs:синеть{}, // синеть в кислородной атмосфере
rus_verbs:слышаться{}, // слышаться в голосе
rus_verbs:закрыться{}, // закрыться в здании
rus_verbs:скрываться{}, // скрываться в квартире
rus_verbs:родить{}, // родить в больнице
rus_verbs:описать{}, // описать в заметках
rus_verbs:перехватить{}, // перехватить в коридоре
rus_verbs:менять{}, // менять в магазине
rus_verbs:скрывать{}, // скрывать в чужой квартире
rus_verbs:стиснуть{}, // стиснуть в стальных объятиях
rus_verbs:останавливаться{}, // останавливаться в гостинице
rus_verbs:мелькать{}, // мелькать в телевизоре
rus_verbs:присутствовать{}, // присутствовать в аудитории
rus_verbs:украсть{}, // украсть в магазине
rus_verbs:победить{}, // победить в войне
rus_verbs:расположиться{}, // расположиться в гостинице
rus_verbs:упомянуть{}, // упомянуть в своей книге
rus_verbs:плыть{}, // плыть в старой бочке
rus_verbs:нащупать{}, // нащупать в глубине
rus_verbs:проявляться{}, // проявляться в работе
rus_verbs:затихнуть{}, // затихнуть в норе
rus_verbs:построить{}, // построить в гараже
rus_verbs:поддерживать{}, // поддерживать в исправном состоянии
rus_verbs:заработать{}, // заработать в стартапе
rus_verbs:сломать{}, // сломать в суставе
rus_verbs:снимать{}, // снимать в гардеробе
rus_verbs:сохранить{}, // сохранить в коллекции
rus_verbs:располагаться{}, // располагаться в отдельном кабинете
rus_verbs:сражаться{}, // сражаться в честном бою
rus_verbs:спускаться{}, // спускаться в батискафе
rus_verbs:уничтожить{}, // уничтожить в схроне
rus_verbs:изучить{}, // изучить в естественных условиях
rus_verbs:рождаться{}, // рождаться в муках
rus_verbs:пребывать{}, // пребывать в прострации
rus_verbs:прилететь{}, // прилететь в аэробусе
rus_verbs:догнать{}, // догнать в переулке
rus_verbs:изобразить{}, // изобразить в танце
rus_verbs:проехать{}, // проехать в легковушке
rus_verbs:убедить{}, // убедить в разумности
rus_verbs:приготовить{}, // приготовить в духовке
rus_verbs:собирать{}, // собирать в лесу
rus_verbs:поплыть{}, // поплыть в катере
rus_verbs:доверять{}, // доверять в управлении
rus_verbs:разобраться{}, // разобраться в законах
rus_verbs:ловить{}, // ловить в озере
rus_verbs:проесть{}, // проесть в куске металла отверстие
rus_verbs:спрятаться{}, // спрятаться в подвале
rus_verbs:провозгласить{}, // провозгласить в речи
rus_verbs:изложить{}, // изложить в своём выступлении
rus_verbs:замяться{}, // замяться в коридоре
rus_verbs:раздаваться{}, // Крик ягуара раздается в джунглях
rus_verbs:доказать{}, // Автор доказал в своей работе, что теорема верна
rus_verbs:хранить{}, // хранить в шкатулке
rus_verbs:шутить{}, // шутить в классе
глагол:рассыпаться{ aux stress="рассып^аться" }, // рассыпаться в извинениях
инфинитив:рассыпаться{ aux stress="рассып^аться" },
rus_verbs:чертить{}, // чертить в тетрадке
rus_verbs:отразиться{}, // отразиться в аттестате
rus_verbs:греть{}, // греть в микроволновке
rus_verbs:зарычать{}, // Кто-то зарычал в глубине леса
rus_verbs:рассуждать{}, // Автор рассуждает в своей статье
rus_verbs:освободить{}, // Обвиняемые были освобождены в зале суда
rus_verbs:окружать{}, // окружать в лесу
rus_verbs:сопровождать{}, // сопровождать в операции
rus_verbs:заканчиваться{}, // заканчиваться в дороге
rus_verbs:поселиться{}, // поселиться в загородном доме
rus_verbs:охватывать{}, // охватывать в хронологии
rus_verbs:запеть{}, // запеть в кино
инфинитив:провозить{вид:несоверш}, // провозить в багаже
глагол:провозить{вид:несоверш},
rus_verbs:мочить{}, // мочить в сортире
rus_verbs:перевернуться{}, // перевернуться в полёте
rus_verbs:улететь{}, // улететь в теплые края
rus_verbs:сдержать{}, // сдержать в руках
rus_verbs:преследовать{}, // преследовать в любой другой стране
rus_verbs:драться{}, // драться в баре
rus_verbs:просидеть{}, // просидеть в классе
rus_verbs:убираться{}, // убираться в квартире
rus_verbs:содрогнуться{}, // содрогнуться в приступе отвращения
rus_verbs:пугать{}, // пугать в прессе
rus_verbs:отреагировать{}, // отреагировать в прессе
rus_verbs:проверять{}, // проверять в аппарате
rus_verbs:убеждать{}, // убеждать в отсутствии альтернатив
rus_verbs:летать{}, // летать в комфортабельном частном самолёте
rus_verbs:толпиться{}, // толпиться в фойе
rus_verbs:плавать{}, // плавать в специальном костюме
rus_verbs:пробыть{}, // пробыть в воде слишком долго
rus_verbs:прикинуть{}, // прикинуть в уме
rus_verbs:застрять{}, // застрять в лифте
rus_verbs:метаться{}, // метаться в кровате
rus_verbs:сжечь{}, // сжечь в печке
rus_verbs:расслабиться{}, // расслабиться в ванной
rus_verbs:услыхать{}, // услыхать в автобусе
rus_verbs:удержать{}, // удержать в вертикальном положении
rus_verbs:образоваться{}, // образоваться в верхних слоях атмосферы
rus_verbs:рассмотреть{}, // рассмотреть в капле воды
rus_verbs:просмотреть{}, // просмотреть в браузере
rus_verbs:учесть{}, // учесть в планах
rus_verbs:уезжать{}, // уезжать в чьей-то машине
rus_verbs:похоронить{}, // похоронить в мерзлой земле
rus_verbs:растянуться{}, // растянуться в расслабленной позе
rus_verbs:обнаружиться{}, // обнаружиться в чужой сумке
rus_verbs:гулять{}, // гулять в парке
rus_verbs:утонуть{}, // утонуть в реке
rus_verbs:зажать{}, // зажать в медвежьих объятиях
rus_verbs:усомниться{}, // усомниться в объективности
rus_verbs:танцевать{}, // танцевать в спортзале
rus_verbs:проноситься{}, // проноситься в голове
rus_verbs:трудиться{}, // трудиться в кооперативе
глагол:засыпать{ aux stress="засып^ать" переходность:непереходный }, // засыпать в спальном мешке
инфинитив:засыпать{ aux stress="засып^ать" переходность:непереходный },
rus_verbs:сушить{}, // сушить в сушильном шкафу
rus_verbs:зашевелиться{}, // зашевелиться в траве
rus_verbs:обдумывать{}, // обдумывать в спокойной обстановке
rus_verbs:промелькнуть{}, // промелькнуть в окне
rus_verbs:поучаствовать{}, // поучаствовать в обсуждении
rus_verbs:закрыть{}, // закрыть в комнате
rus_verbs:запирать{}, // запирать в комнате
rus_verbs:закрывать{}, // закрывать в доме
rus_verbs:заблокировать{}, // заблокировать в доме
rus_verbs:зацвести{}, // В садах зацвела сирень
rus_verbs:кричать{}, // Какое-то животное кричало в ночном лесу.
rus_verbs:поглотить{}, // фотон, поглощенный в рецепторе
rus_verbs:стоять{}, // войска, стоявшие в Риме
rus_verbs:закалить{}, // ветераны, закаленные в боях
rus_verbs:выступать{}, // пришлось выступать в тюрьме.
rus_verbs:выступить{}, // пришлось выступить в тюрьме.
rus_verbs:закопошиться{}, // Мыши закопошились в траве
rus_verbs:воспламениться{}, // смесь, воспламенившаяся в цилиндре
rus_verbs:воспламеняться{}, // смесь, воспламеняющаяся в цилиндре
rus_verbs:закрываться{}, // закрываться в комнате
rus_verbs:провалиться{}, // провалиться в прокате
деепричастие:авторизируясь{ вид:несоверш },
глагол:авторизироваться{ вид:несоверш },
инфинитив:авторизироваться{ вид:несоверш }, // авторизироваться в системе
rus_verbs:существовать{}, // существовать в вакууме
деепричастие:находясь{},
прилагательное:находившийся{},
прилагательное:находящийся{},
глагол:находиться{ вид:несоверш },
инфинитив:находиться{ вид:несоверш }, // находиться в вакууме
rus_verbs:регистрировать{}, // регистрировать в инспекции
глагол:перерегистрировать{ вид:несоверш }, глагол:перерегистрировать{ вид:соверш },
инфинитив:перерегистрировать{ вид:несоверш }, инфинитив:перерегистрировать{ вид:соверш }, // перерегистрировать в инспекции
rus_verbs:поковыряться{}, // поковыряться в носу
rus_verbs:оттаять{}, // оттаять в кипятке
rus_verbs:распинаться{}, // распинаться в проклятиях
rus_verbs:отменить{}, // Министерство связи предлагает отменить внутренний роуминг в России
rus_verbs:столкнуться{}, // Американский эсминец и японский танкер столкнулись в Персидском заливе
rus_verbs:ценить{}, // Он очень ценил в статьях краткость изложения.
прилагательное:несчастный{}, // Он очень несчастен в семейной жизни.
rus_verbs:объясниться{}, // Он объяснился в любви.
прилагательное:нетвердый{}, // Он нетвёрд в истории.
rus_verbs:заниматься{}, // Он занимается в читальном зале.
rus_verbs:вращаться{}, // Он вращается в учёных кругах.
прилагательное:спокойный{}, // Он был спокоен и уверен в завтрашнем дне.
rus_verbs:бегать{}, // Он бегал по городу в поисках квартиры.
rus_verbs:заключать{}, // Письмо заключало в себе очень важные сведения.
rus_verbs:срабатывать{}, // Алгоритм срабатывает в половине случаев.
rus_verbs:специализироваться{}, // мы специализируемся в создании ядерного оружия
rus_verbs:сравниться{}, // Никто не может сравниться с ним в знаниях.
rus_verbs:продолжать{}, // Продолжайте в том же духе.
rus_verbs:говорить{}, // Не говорите об этом в присутствии третьих лиц.
rus_verbs:болтать{}, // Не болтай в присутствии начальника!
rus_verbs:проболтаться{}, // Не проболтайся в присутствии начальника!
rus_verbs:повторить{}, // Он должен повторить свои показания в присутствии свидетелей
rus_verbs:получить{}, // ректор поздравил студентов, получивших в этом семестре повышенную стипендию
rus_verbs:приобретать{}, // Эту еду мы приобретаем в соседнем магазине.
rus_verbs:расходиться{}, // Маша и Петя расходятся во взглядах
rus_verbs:сходиться{}, // Все дороги сходятся в Москве
rus_verbs:убирать{}, // убирать в комнате
rus_verbs:удостоверяться{}, // он удостоверяется в личности специалиста
rus_verbs:уединяться{}, // уединяться в пустыне
rus_verbs:уживаться{}, // уживаться в одном коллективе
rus_verbs:укорять{}, // укорять друга в забывчивости
rus_verbs:читать{}, // он читал об этом в журнале
rus_verbs:состояться{}, // В Израиле состоятся досрочные парламентские выборы
rus_verbs:погибнуть{}, // Список погибших в авиакатастрофе под Ярославлем
rus_verbs:работать{}, // Я работаю в театре.
rus_verbs:признать{}, // Я признал в нём старого друга.
rus_verbs:преподавать{}, // Я преподаю в университете.
rus_verbs:понимать{}, // Я плохо понимаю в живописи.
rus_verbs:водиться{}, // неизвестный науке зверь, который водится в жарких тропических лесах
rus_verbs:разразиться{}, // В Москве разразилась эпидемия гриппа
rus_verbs:замереть{}, // вся толпа замерла в восхищении
rus_verbs:сидеть{}, // Я люблю сидеть в этом удобном кресле.
rus_verbs:идти{}, // Я иду в неопределённом направлении.
rus_verbs:заболеть{}, // Я заболел в дороге.
rus_verbs:ехать{}, // Я еду в автобусе
rus_verbs:взять{}, // Я взял книгу в библиотеке на неделю.
rus_verbs:провести{}, // Юные годы он провёл в Италии.
rus_verbs:вставать{}, // Этот случай живо встаёт в моей памяти.
rus_verbs:возвысить{}, // Это событие возвысило его в общественном мнении.
rus_verbs:произойти{}, // Это произошло в одном городе в Японии.
rus_verbs:привидеться{}, // Это мне привиделось во сне.
rus_verbs:держаться{}, // Это дело держится в большом секрете.
rus_verbs:привиться{}, // Это выражение не привилось в русском языке.
rus_verbs:восстановиться{}, // Эти писатели восстановились в правах.
rus_verbs:быть{}, // Эта книга есть в любом книжном магазине.
прилагательное:популярный{}, // Эта идея очень популярна в массах.
rus_verbs:шуметь{}, // Шумит в голове.
rus_verbs:остаться{}, // Шляпа осталась в поезде.
rus_verbs:выражаться{}, // Характер писателя лучше всего выражается в его произведениях.
rus_verbs:воспитать{}, // Учительница воспитала в детях любовь к природе.
rus_verbs:пересохнуть{}, // У меня в горле пересохло.
rus_verbs:щекотать{}, // У меня в горле щекочет.
rus_verbs:колоть{}, // У меня в боку колет.
прилагательное:свежий{}, // Событие ещё свежо в памяти.
rus_verbs:собрать{}, // Соберите всех учеников во дворе.
rus_verbs:белеть{}, // Снег белеет в горах.
rus_verbs:сделать{}, // Сколько орфографических ошибок ты сделал в диктанте?
rus_verbs:таять{}, // Сахар тает в кипятке.
rus_verbs:жать{}, // Сапог жмёт в подъёме.
rus_verbs:возиться{}, // Ребята возятся в углу.
rus_verbs:распоряжаться{}, // Прошу не распоряжаться в чужом доме.
rus_verbs:кружиться{}, // Они кружились в вальсе.
rus_verbs:выставлять{}, // Они выставляют его в смешном виде.
rus_verbs:бывать{}, // Она часто бывает в обществе.
rus_verbs:петь{}, // Она поёт в опере.
rus_verbs:сойтись{}, // Все свидетели сошлись в своих показаниях.
rus_verbs:валяться{}, // Вещи валялись в беспорядке.
rus_verbs:пройти{}, // Весь день прошёл в беготне.
rus_verbs:продавать{}, // В этом магазине продают обувь.
rus_verbs:заключаться{}, // В этом заключается вся сущность.
rus_verbs:звенеть{}, // В ушах звенит.
rus_verbs:проступить{}, // В тумане проступили очертания корабля.
rus_verbs:бить{}, // В саду бьёт фонтан.
rus_verbs:проскользнуть{}, // В речи проскользнул упрёк.
rus_verbs:оставить{}, // Не оставь товарища в опасности.
rus_verbs:прогулять{}, // Мы прогуляли час в парке.
rus_verbs:перебить{}, // Мы перебили врагов в бою.
rus_verbs:остановиться{}, // Мы остановились в первой попавшейся гостинице.
rus_verbs:видеть{}, // Он многое видел в жизни.
// глагол:проходить{ вид:несоверш }, // Беседа проходила в дружественной атмосфере.
rus_verbs:подать{}, // Автор подал своих героев в реалистических тонах.
rus_verbs:кинуть{}, // Он кинул меня в беде.
rus_verbs:приходить{}, // Приходи в сентябре
rus_verbs:воскрешать{}, // воскрешать в памяти
rus_verbs:соединять{}, // соединять в себе
rus_verbs:разбираться{}, // умение разбираться в вещах
rus_verbs:делать{}, // В её комнате делали обыск.
rus_verbs:воцариться{}, // В зале воцарилась глубокая тишина.
rus_verbs:начаться{}, // В деревне начались полевые работы.
rus_verbs:блеснуть{}, // В голове блеснула хорошая мысль.
rus_verbs:вертеться{}, // В голове вертится вчерашний разговор.
rus_verbs:веять{}, // В воздухе веет прохладой.
rus_verbs:висеть{}, // В воздухе висит зной.
rus_verbs:носиться{}, // В воздухе носятся комары.
rus_verbs:грести{}, // Грести в спокойной воде будет немного легче, но скучнее
rus_verbs:воскресить{}, // воскресить в памяти
rus_verbs:поплавать{}, // поплавать в 100-метровом бассейне
rus_verbs:пострадать{}, // В массовой драке пострадал 23-летний мужчина
прилагательное:уверенный{ причастие }, // Она уверена в своих силах.
прилагательное:постоянный{}, // Она постоянна во вкусах.
прилагательное:сильный{}, // Он не силён в математике.
прилагательное:повинный{}, // Он не повинен в этом.
прилагательное:возможный{}, // Ураганы, сильные грозы и даже смерчи возможны в конце периода сильной жары
rus_verbs:вывести{}, // способный летать над землей крокодил был выведен в секретной лаборатории
прилагательное:нужный{}, // сковородка тоже нужна в хозяйстве.
rus_verbs:сесть{}, // Она села в тени
rus_verbs:заливаться{}, // в нашем парке заливаются соловьи
rus_verbs:разнести{}, // В лесу огонь пожара мгновенно разнесло
rus_verbs:чувствоваться{}, // В тёплом, но сыром воздухе остро чувствовалось дыхание осени
// rus_verbs:расти{}, // дерево, растущее в лесу
rus_verbs:происходить{}, // что происходит в поликлиннике
rus_verbs:спать{}, // кто спит в моей кровати
rus_verbs:мыть{}, // мыть машину в саду
ГЛ_ИНФ(царить), // В воздухе царило безмолвие
ГЛ_ИНФ(мести), // мести в прихожей пол
ГЛ_ИНФ(прятать), // прятать в яме
ГЛ_ИНФ(увидеть), прилагательное:увидевший{}, деепричастие:увидев{}, // увидел периодическую таблицу элементов во сне.
// ГЛ_ИНФ(собраться), // собраться в порту
ГЛ_ИНФ(случиться), // что-то случилось в больнице
ГЛ_ИНФ(зажечься), // в небе зажглись звёзды
ГЛ_ИНФ(купить), // купи молока в магазине
прилагательное:пропагандировавшийся{} // группа студентов университета дружбы народов, активно пропагандировавшейся в СССР
}
// Чтобы разрешить связывание в паттернах типа: пообедать в macdonalds
fact гл_предл
{
if context { Гл_В_Предл предлог:в{} @regex("[a-z]+[0-9]*") }
then return true
}
fact гл_предл
{
if context { Гл_В_Предл предлог:в{} *:*{ падеж:предл } }
then return true
}
// С локативом:
// собраться в порту
fact гл_предл
{
if context { Гл_В_Предл предлог:в{} существительное:*{ падеж:мест } }
then return true
}
#endregion Предложный
#region Винительный
// Для глаголов движения с выраженным направлением действия может присоединяться
// предложный паттерн с винительным падежом.
wordentry_set Гл_В_Вин =
{
rus_verbs:вдавиться{}, // Дуло больно вдавилось в позвонок.
глагол:ввергнуть{}, // Двух прелестнейших дам он ввергнул в горе.
глагол:ввергать{},
инфинитив:ввергнуть{},
инфинитив:ввергать{},
rus_verbs:двинуться{}, // Двинулись в путь и мы.
rus_verbs:сплавать{}, // Сплавать в Россию!
rus_verbs:уложиться{}, // Уложиться в воскресенье.
rus_verbs:спешить{}, // Спешите в Лондон
rus_verbs:кинуть{}, // Киньте в море.
rus_verbs:проситься{}, // Просилась в Никарагуа.
rus_verbs:притопать{}, // Притопал в Будапешт.
rus_verbs:скататься{}, // Скатался в Красноярск.
rus_verbs:соскользнуть{}, // Соскользнул в пике.
rus_verbs:соскальзывать{},
rus_verbs:играть{}, // Играл в дутье.
глагол:айда{}, // Айда в каморы.
rus_verbs:отзывать{}, // Отзывали в Москву...
rus_verbs:сообщаться{}, // Сообщается в Лондон.
rus_verbs:вдуматься{}, // Вдумайтесь в них.
rus_verbs:проехать{}, // Проехать в Лунево...
rus_verbs:спрыгивать{}, // Спрыгиваем в него.
rus_verbs:верить{}, // Верю в вас!
rus_verbs:прибыть{}, // Прибыл в Подмосковье.
rus_verbs:переходить{}, // Переходите в школу.
rus_verbs:доложить{}, // Доложили в Москву.
rus_verbs:подаваться{}, // Подаваться в Россию?
rus_verbs:спрыгнуть{}, // Спрыгнул в него.
rus_verbs:вывезти{}, // Вывезли в Китай.
rus_verbs:пропихивать{}, // Я очень аккуратно пропихивал дуло в ноздрю.
rus_verbs:пропихнуть{},
rus_verbs:транспортироваться{},
rus_verbs:закрадываться{}, // в голову начали закрадываться кое-какие сомнения и подозрения
rus_verbs:дуть{},
rus_verbs:БОГАТЕТЬ{}, //
rus_verbs:РАЗБОГАТЕТЬ{}, //
rus_verbs:ВОЗРАСТАТЬ{}, //
rus_verbs:ВОЗРАСТИ{}, //
rus_verbs:ПОДНЯТЬ{}, // Он поднял половинку самолета в воздух и на всей скорости повел ее к горам. (ПОДНЯТЬ)
rus_verbs:ОТКАТИТЬСЯ{}, // Услышав за спиной дыхание, он прыгнул вперед и откатился в сторону, рассчитывая ускользнуть от врага, нападавшего сзади (ОТКАТИТЬСЯ)
rus_verbs:ВПЛЕТАТЬСЯ{}, // В общий смрад вплеталось зловонье пены, летевшей из пастей, и крови из легких (ВПЛЕТАТЬСЯ)
rus_verbs:ЗАМАНИТЬ{}, // Они подумали, что Павел пытается заманить их в зону обстрела. (ЗАМАНИТЬ,ЗАМАНИВАТЬ)
rus_verbs:ЗАМАНИВАТЬ{},
rus_verbs:ПРОТРУБИТЬ{}, // Эти врата откроются, когда он протрубит в рог, и пропустят его в другую вселенную. (ПРОТРУБИТЬ)
rus_verbs:ВРУБИТЬСЯ{}, // Клинок сломался, не врубившись в металл. (ВРУБИТЬСЯ/ВРУБАТЬСЯ)
rus_verbs:ВРУБАТЬСЯ{},
rus_verbs:ОТПРАВИТЬ{}, // Мы ищем благородного вельможу, который нанял бы нас или отправил в рыцарский поиск. (ОТПРАВИТЬ)
rus_verbs:ОБЛАЧИТЬ{}, // Этот был облачен в сверкавшие красные доспехи с опущенным забралом и держал огромное копье, дожидаясь своей очереди. (ОБЛАЧИТЬ/ОБЛАЧАТЬ/ОБЛАЧИТЬСЯ/ОБЛАЧАТЬСЯ/НАРЯДИТЬСЯ/НАРЯЖАТЬСЯ)
rus_verbs:ОБЛАЧАТЬ{},
rus_verbs:ОБЛАЧИТЬСЯ{},
rus_verbs:ОБЛАЧАТЬСЯ{},
rus_verbs:НАРЯДИТЬСЯ{},
rus_verbs:НАРЯЖАТЬСЯ{},
rus_verbs:ЗАХВАТИТЬ{}, // Кроме набранного рабского материала обычного типа, он захватил в плен группу очень странных созданий, а также женщину исключительной красоты (ЗАХВАТИТЬ/ЗАХВАТЫВАТЬ/ЗАХВАТ)
rus_verbs:ЗАХВАТЫВАТЬ{},
rus_verbs:ПРОВЕСТИ{}, // Он провел их в маленькое святилище позади штурвала. (ПРОВЕСТИ)
rus_verbs:ПОЙМАТЬ{}, // Их можно поймать в ловушку (ПОЙМАТЬ)
rus_verbs:СТРОИТЬСЯ{}, // На вершине они остановились, строясь в круг. (СТРОИТЬСЯ,ПОСТРОИТЬСЯ,ВЫСТРОИТЬСЯ)
rus_verbs:ПОСТРОИТЬСЯ{},
rus_verbs:ВЫСТРОИТЬСЯ{},
rus_verbs:ВЫПУСТИТЬ{}, // Несколько стрел, выпущенных в преследуемых, вонзились в траву (ВЫПУСТИТЬ/ВЫПУСКАТЬ)
rus_verbs:ВЫПУСКАТЬ{},
rus_verbs:ВЦЕПЛЯТЬСЯ{}, // Они вцепляются тебе в горло. (ВЦЕПЛЯТЬСЯ/ВЦЕПИТЬСЯ)
rus_verbs:ВЦЕПИТЬСЯ{},
rus_verbs:ПАЛЬНУТЬ{}, // Вольф вставил в тетиву новую стрелу и пальнул в белое брюхо (ПАЛЬНУТЬ)
rus_verbs:ОТСТУПИТЬ{}, // Вольф отступил в щель. (ОТСТУПИТЬ/ОТСТУПАТЬ)
rus_verbs:ОТСТУПАТЬ{},
rus_verbs:КРИКНУТЬ{}, // Вольф крикнул в ответ и медленно отступил от птицы. (КРИКНУТЬ)
rus_verbs:ДЫХНУТЬ{}, // В лицо ему дыхнули винным перегаром. (ДЫХНУТЬ)
rus_verbs:ПОТРУБИТЬ{}, // Я видел рог во время своих скитаний по дворцу и даже потрубил в него (ПОТРУБИТЬ)
rus_verbs:ОТКРЫВАТЬСЯ{}, // Некоторые врата открывались в другие вселенные (ОТКРЫВАТЬСЯ)
rus_verbs:ТРУБИТЬ{}, // А я трубил в рог (ТРУБИТЬ)
rus_verbs:ПЫРНУТЬ{}, // Вольф пырнул его в бок. (ПЫРНУТЬ)
rus_verbs:ПРОСКРЕЖЕТАТЬ{}, // Тот что-то проскрежетал в ответ, а затем наорал на него. (ПРОСКРЕЖЕТАТЬ В вин, НАОРАТЬ НА вин)
rus_verbs:ИМПОРТИРОВАТЬ{}, // импортировать товары двойного применения только в Российскую Федерацию (ИМПОРТИРОВАТЬ)
rus_verbs:ОТЪЕХАТЬ{}, // Легкий грохот катков заглушил рог, когда дверь отъехала в сторону. (ОТЪЕХАТЬ)
rus_verbs:ПОПЛЕСТИСЬ{}, // Подобрав нижнее белье, носки и ботинки, он поплелся по песку обратно в джунгли. (ПОПЛЕЛСЯ)
rus_verbs:СЖАТЬСЯ{}, // Желудок у него сжался в кулак. (СЖАТЬСЯ, СЖИМАТЬСЯ)
rus_verbs:СЖИМАТЬСЯ{},
rus_verbs:проверять{}, // Школьников будут принудительно проверять на курение
rus_verbs:ПОТЯНУТЬ{}, // Я потянул его в кино (ПОТЯНУТЬ)
rus_verbs:ПЕРЕВЕСТИ{}, // Премьер-министр Казахстана поручил до конца года перевести все социально-значимые услуги в электронный вид (ПЕРЕВЕСТИ)
rus_verbs:КРАСИТЬ{}, // Почему китайские партийные боссы красят волосы в черный цвет? (КРАСИТЬ/ПОКРАСИТЬ/ПЕРЕКРАСИТЬ/ОКРАСИТЬ/ЗАКРАСИТЬ)
rus_verbs:ПОКРАСИТЬ{}, //
rus_verbs:ПЕРЕКРАСИТЬ{}, //
rus_verbs:ОКРАСИТЬ{}, //
rus_verbs:ЗАКРАСИТЬ{}, //
rus_verbs:СООБЩИТЬ{}, // Мужчина ранил человека в щеку и сам сообщил об этом в полицию (СООБЩИТЬ)
rus_verbs:СТЯГИВАТЬ{}, // Но толщина пузыря постоянно меняется из-за гравитации, которая стягивает жидкость в нижнюю часть (СТЯГИВАТЬ/СТЯНУТЬ/ЗАТЯНУТЬ/ВТЯНУТЬ)
rus_verbs:СТЯНУТЬ{}, //
rus_verbs:ЗАТЯНУТЬ{}, //
rus_verbs:ВТЯНУТЬ{}, //
rus_verbs:СОХРАНИТЬ{}, // сохранить данные в файл (СОХРАНИТЬ)
деепричастие:придя{}, // Немного придя в себя
rus_verbs:наблюдать{}, // Судья , долго наблюдавший в трубу , вдруг вскричал
rus_verbs:УЛЫБАТЬСЯ{}, // она улыбалась во весь рот (УЛЫБАТЬСЯ)
rus_verbs:МЕТНУТЬСЯ{}, // она метнулась обратно во тьму (МЕТНУТЬСЯ)
rus_verbs:ПОСЛЕДОВАТЬ{}, // большинство жителей города последовало за ним во дворец (ПОСЛЕДОВАТЬ)
rus_verbs:ПЕРЕМЕЩАТЬСЯ{}, // экстремисты перемещаются из лесов в Сеть (ПЕРЕМЕЩАТЬСЯ)
rus_verbs:ВЫТАЩИТЬ{}, // Алексей позволил вытащить себя через дверь во тьму (ВЫТАЩИТЬ)
rus_verbs:СЫПАТЬСЯ{}, // внизу под ними камни градом сыпались во двор (СЫПАТЬСЯ)
rus_verbs:выезжать{}, // заключенные сами шьют куклы и иногда выезжают с представлениями в детский дом неподалеку
rus_verbs:КРИЧАТЬ{}, // ей хотелось кричать во весь голос (КРИЧАТЬ В вин)
rus_verbs:ВЫПРЯМИТЬСЯ{}, // волк выпрямился во весь огромный рост (ВЫПРЯМИТЬСЯ В вин)
rus_verbs:спрятать{}, // Джон спрятал очки во внутренний карман (спрятать в вин)
rus_verbs:ЭКСТРАДИРОВАТЬ{}, // Украина экстрадирует в Таджикистан задержанного бывшего премьер-министра (ЭКСТРАДИРОВАТЬ В вин)
rus_verbs:ВВОЗИТЬ{}, // лабораторный мониторинг ввозимой в Россию мясной продукции из США (ВВОЗИТЬ В вин)
rus_verbs:УПАКОВАТЬ{}, // упакованных в несколько слоев полиэтилена (УПАКОВАТЬ В вин)
rus_verbs:ОТТЯГИВАТЬ{}, // использовать естественную силу гравитации, оттягивая объекты в сторону и изменяя их орбиту (ОТТЯГИВАТЬ В вин)
rus_verbs:ПОЗВОНИТЬ{}, // они позвонили в отдел экологии городской администрации (ПОЗВОНИТЬ В)
rus_verbs:ПРИВЛЕЧЬ{}, // Открытость данных о лесе поможет привлечь инвестиции в отрасль (ПРИВЛЕЧЬ В)
rus_verbs:ЗАПРОСИТЬСЯ{}, // набегавшись и наплясавшись, Стасик утомился и запросился в кроватку (ЗАПРОСИТЬСЯ В)
rus_verbs:ОТСТАВИТЬ{}, // бутыль с ацетоном Витька отставил в сторонку (ОТСТАВИТЬ В)
rus_verbs:ИСПОЛЬЗОВАТЬ{}, // ты использовал свою магию во зло. (ИСПОЛЬЗОВАТЬ В вин)
rus_verbs:ВЫСЕВАТЬ{}, // В апреле редис возможно уже высевать в грунт (ВЫСЕВАТЬ В)
rus_verbs:ЗАГНАТЬ{}, // Американский психолог загнал любовь в три угла (ЗАГНАТЬ В)
rus_verbs:ЭВОЛЮЦИОНИРОВАТЬ{}, // Почему не все обезьяны эволюционировали в человека? (ЭВОЛЮЦИОНИРОВАТЬ В вин)
rus_verbs:СФОТОГРАФИРОВАТЬСЯ{}, // Он сфотографировался во весь рост. (СФОТОГРАФИРОВАТЬСЯ В)
rus_verbs:СТАВИТЬ{}, // Он ставит мне в упрёк свою ошибку. (СТАВИТЬ В)
rus_verbs:расщепляться{}, // Сахароза же быстро расщепляется в пищеварительном тракте на глюкозу и фруктозу (РАСЩЕПЛЯТЬСЯ В, НА)
rus_verbs:ПЕРЕСЕЛЯТЬСЯ{}, // Греки переселяются в Германию (ПЕРЕСЕЛЯТЬСЯ В)
rus_verbs:ФОРМИРОВАТЬСЯ{}, // Сахарная свекла относится к двулетним растениям, мясистый корнеплод формируется в первый год. (ФОРМИРОВАТЬСЯ В)
rus_verbs:ПРОВОРЧАТЬ{}, // дедуля что-то проворчал в ответ (ПРОВОРЧАТЬ В)
rus_verbs:БУРКНУТЬ{}, // нелюдимый парень что-то буркнул в ответ (БУРКНУТЬ В)
rus_verbs:ВЕСТИ{}, // дверь вела во тьму. (ВЕСТИ В)
rus_verbs:ВЫСКОЧИТЬ{}, // беглецы выскочили во двор. (ВЫСКОЧИТЬ В)
rus_verbs:ДОСЫЛАТЬ{}, // Одним движением стрелок досылает патрон в ствол (ДОСЫЛАТЬ В)
rus_verbs:СЪЕХАТЬСЯ{}, // Финалисты съехались на свои игры в Лос-Анжелес. (СЪЕХАТЬСЯ НА, В)
rus_verbs:ВЫТЯНУТЬ{}, // Дым вытянуло в трубу. (ВЫТЯНУТЬ В)
rus_verbs:торчать{}, // острые обломки бревен торчали во все стороны.
rus_verbs:ОГЛЯДЫВАТЬ{}, // Она оглядывает себя в зеркало. (ОГЛЯДЫВАТЬ В)
rus_verbs:ДЕЙСТВОВАТЬ{}, // Этот пакет законов действует в ущерб частным предпринимателям.
rus_verbs:РАЗЛЕТЕТЬСЯ{}, // люди разлетелись во все стороны. (РАЗЛЕТЕТЬСЯ В)
rus_verbs:брызнуть{}, // во все стороны брызнула кровь. (брызнуть в)
rus_verbs:ТЯНУТЬСЯ{}, // провода тянулись во все углы. (ТЯНУТЬСЯ В)
rus_verbs:валить{}, // валить все в одну кучу (валить в)
rus_verbs:выдвинуть{}, // его выдвинули в палату представителей (выдвинуть в)
rus_verbs:карабкаться{}, // карабкаться в гору (карабкаться в)
rus_verbs:клониться{}, // он клонился в сторону (клониться в)
rus_verbs:командировать{}, // мы командировали нашего представителя в Рим (командировать в)
rus_verbs:запасть{}, // Эти слова запали мне в душу.
rus_verbs:давать{}, // В этой лавке дают в долг?
rus_verbs:ездить{}, // Каждый день грузовик ездит в город.
rus_verbs:претвориться{}, // Замысел претворился в жизнь.
rus_verbs:разойтись{}, // Они разошлись в разные стороны.
rus_verbs:выйти{}, // Охотник вышел в поле с ружьём.
rus_verbs:отозвать{}, // Отзовите его в сторону и скажите ему об этом.
rus_verbs:расходиться{}, // Маша и Петя расходятся в разные стороны
rus_verbs:переодеваться{}, // переодеваться в женское платье
rus_verbs:перерастать{}, // перерастать в массовые беспорядки
rus_verbs:завязываться{}, // завязываться в узел
rus_verbs:похватать{}, // похватать в руки
rus_verbs:увлечь{}, // увлечь в прогулку по парку
rus_verbs:помещать{}, // помещать в изолятор
rus_verbs:зыркнуть{}, // зыркнуть в окошко
rus_verbs:закатать{}, // закатать в асфальт
rus_verbs:усаживаться{}, // усаживаться в кресло
rus_verbs:загонять{}, // загонять в сарай
rus_verbs:подбрасывать{}, // подбрасывать в воздух
rus_verbs:телеграфировать{}, // телеграфировать в центр
rus_verbs:вязать{}, // вязать в стопы
rus_verbs:подлить{}, // подлить в огонь
rus_verbs:заполучить{}, // заполучить в распоряжение
rus_verbs:подогнать{}, // подогнать в док
rus_verbs:ломиться{}, // ломиться в открытую дверь
rus_verbs:переправить{}, // переправить в деревню
rus_verbs:затягиваться{}, // затягиваться в трубу
rus_verbs:разлетаться{}, // разлетаться в стороны
rus_verbs:кланяться{}, // кланяться в ножки
rus_verbs:устремляться{}, // устремляться в открытое море
rus_verbs:переместиться{}, // переместиться в другую аудиторию
rus_verbs:ложить{}, // ложить в ящик
rus_verbs:отвозить{}, // отвозить в аэропорт
rus_verbs:напрашиваться{}, // напрашиваться в гости
rus_verbs:напроситься{}, // напроситься в гости
rus_verbs:нагрянуть{}, // нагрянуть в гости
rus_verbs:заворачивать{}, // заворачивать в фольгу
rus_verbs:заковать{}, // заковать в кандалы
rus_verbs:свезти{}, // свезти в сарай
rus_verbs:притащиться{}, // притащиться в дом
rus_verbs:завербовать{}, // завербовать в разведку
rus_verbs:рубиться{}, // рубиться в компьютерные игры
rus_verbs:тыкаться{}, // тыкаться в материнскую грудь
инфинитив:ссыпать{ вид:несоверш }, инфинитив:ссыпать{ вид:соверш }, // ссыпать в контейнер
глагол:ссыпать{ вид:несоверш }, глагол:ссыпать{ вид:соверш },
деепричастие:ссыпав{}, деепричастие:ссыпая{},
rus_verbs:засасывать{}, // засасывать в себя
rus_verbs:скакнуть{}, // скакнуть в будущее
rus_verbs:подвозить{}, // подвозить в театр
rus_verbs:переиграть{}, // переиграть в покер
rus_verbs:мобилизовать{}, // мобилизовать в действующую армию
rus_verbs:залетать{}, // залетать в закрытое воздушное пространство
rus_verbs:подышать{}, // подышать в трубочку
rus_verbs:смотаться{}, // смотаться в институт
rus_verbs:рассовать{}, // рассовать в кармашки
rus_verbs:захаживать{}, // захаживать в дом
инфинитив:сгонять{ вид:соверш }, глагол:сгонять{ вид:соверш }, // сгонять в ломбард
деепричастие:сгоняя{},
rus_verbs:посылаться{}, // посылаться в порт
rus_verbs:отлить{}, // отлить в кастрюлю
rus_verbs:преобразоваться{}, // преобразоваться в линейное уравнение
rus_verbs:поплакать{}, // поплакать в платочек
rus_verbs:обуться{}, // обуться в сапоги
rus_verbs:закапать{}, // закапать в глаза
инфинитив:свозить{ вид:несоверш }, инфинитив:свозить{ вид:соверш }, // свозить в центр утилизации
глагол:свозить{ вид:несоверш }, глагол:свозить{ вид:соверш },
деепричастие:свозив{}, деепричастие:свозя{},
rus_verbs:преобразовать{}, // преобразовать в линейное уравнение
rus_verbs:кутаться{}, // кутаться в плед
rus_verbs:смещаться{}, // смещаться в сторону
rus_verbs:зазывать{}, // зазывать в свой магазин
инфинитив:трансформироваться{ вид:несоверш }, инфинитив:трансформироваться{ вид:соверш }, // трансформироваться в комбинезон
глагол:трансформироваться{ вид:несоверш }, глагол:трансформироваться{ вид:соверш },
деепричастие:трансформируясь{}, деепричастие:трансформировавшись{},
rus_verbs:погружать{}, // погружать в кипящее масло
rus_verbs:обыграть{}, // обыграть в теннис
rus_verbs:закутать{}, // закутать в одеяло
rus_verbs:изливаться{}, // изливаться в воду
rus_verbs:закатывать{}, // закатывать в асфальт
rus_verbs:мотнуться{}, // мотнуться в банк
rus_verbs:избираться{}, // избираться в сенат
rus_verbs:наниматься{}, // наниматься в услужение
rus_verbs:настучать{}, // настучать в органы
rus_verbs:запихивать{}, // запихивать в печку
rus_verbs:закапывать{}, // закапывать в нос
rus_verbs:засобираться{}, // засобираться в поход
rus_verbs:копировать{}, // копировать в другую папку
rus_verbs:замуровать{}, // замуровать в стену
rus_verbs:упечь{}, // упечь в тюрьму
rus_verbs:зрить{}, // зрить в корень
rus_verbs:стягиваться{}, // стягиваться в одну точку
rus_verbs:усаживать{}, // усаживать в тренажер
rus_verbs:протолкнуть{}, // протолкнуть в отверстие
rus_verbs:расшибиться{}, // расшибиться в лепешку
rus_verbs:приглашаться{}, // приглашаться в кабинет
rus_verbs:садить{}, // садить в телегу
rus_verbs:уткнуть{}, // уткнуть в подушку
rus_verbs:протечь{}, // протечь в подвал
rus_verbs:перегнать{}, // перегнать в другую страну
rus_verbs:переползти{}, // переползти в тень
rus_verbs:зарываться{}, // зарываться в грунт
rus_verbs:переодеть{}, // переодеть в сухую одежду
rus_verbs:припуститься{}, // припуститься в пляс
rus_verbs:лопотать{}, // лопотать в микрофон
rus_verbs:прогнусавить{}, // прогнусавить в микрофон
rus_verbs:мочиться{}, // мочиться в штаны
rus_verbs:загружать{}, // загружать в патронник
rus_verbs:радировать{}, // радировать в центр
rus_verbs:промотать{}, // промотать в конец
rus_verbs:помчать{}, // помчать в школу
rus_verbs:съезжать{}, // съезжать в кювет
rus_verbs:завозить{}, // завозить в магазин
rus_verbs:заявляться{}, // заявляться в школу
rus_verbs:наглядеться{}, // наглядеться в зеркало
rus_verbs:сворачиваться{}, // сворачиваться в клубочек
rus_verbs:устремлять{}, // устремлять взор в будущее
rus_verbs:забредать{}, // забредать в глухие уголки
rus_verbs:перемотать{}, // перемотать в самое начало диалога
rus_verbs:сморкаться{}, // сморкаться в носовой платочек
rus_verbs:перетекать{}, // перетекать в другой сосуд
rus_verbs:закачать{}, // закачать в шарик
rus_verbs:запрятать{}, // запрятать в сейф
rus_verbs:пинать{}, // пинать в живот
rus_verbs:затрубить{}, // затрубить в горн
rus_verbs:подглядывать{}, // подглядывать в замочную скважину
инфинитив:подсыпать{ вид:соверш }, инфинитив:подсыпать{ вид:несоверш }, // подсыпать в питье
глагол:подсыпать{ вид:соверш }, глагол:подсыпать{ вид:несоверш },
деепричастие:подсыпав{}, деепричастие:подсыпая{},
rus_verbs:засовывать{}, // засовывать в пенал
rus_verbs:отрядить{}, // отрядить в командировку
rus_verbs:справлять{}, // справлять в кусты
rus_verbs:поторапливаться{}, // поторапливаться в самолет
rus_verbs:скопировать{}, // скопировать в кэш
rus_verbs:подливать{}, // подливать в огонь
rus_verbs:запрячь{}, // запрячь в повозку
rus_verbs:окраситься{}, // окраситься в пурпур
rus_verbs:уколоть{}, // уколоть в шею
rus_verbs:слететься{}, // слететься в гнездо
rus_verbs:резаться{}, // резаться в карты
rus_verbs:затесаться{}, // затесаться в ряды оппозиционеров
инфинитив:задвигать{ вид:несоверш }, глагол:задвигать{ вид:несоверш }, // задвигать в ячейку (несоверш)
деепричастие:задвигая{},
rus_verbs:доставляться{}, // доставляться в ресторан
rus_verbs:поплевать{}, // поплевать в чашку
rus_verbs:попереться{}, // попереться в магазин
rus_verbs:хаживать{}, // хаживать в церковь
rus_verbs:преображаться{}, // преображаться в королеву
rus_verbs:организоваться{}, // организоваться в группу
rus_verbs:ужалить{}, // ужалить в руку
rus_verbs:протискиваться{}, // протискиваться в аудиторию
rus_verbs:препроводить{}, // препроводить в закуток
rus_verbs:разъезжаться{}, // разъезжаться в разные стороны
rus_verbs:пропыхтеть{}, // пропыхтеть в трубку
rus_verbs:уволочь{}, // уволочь в нору
rus_verbs:отодвигаться{}, // отодвигаться в сторону
rus_verbs:разливать{}, // разливать в стаканы
rus_verbs:сбегаться{}, // сбегаться в актовый зал
rus_verbs:наведаться{}, // наведаться в кладовку
rus_verbs:перекочевать{}, // перекочевать в горы
rus_verbs:прощебетать{}, // прощебетать в трубку
rus_verbs:перекладывать{}, // перекладывать в другой карман
rus_verbs:углубляться{}, // углубляться в теорию
rus_verbs:переименовать{}, // переименовать в город
rus_verbs:переметнуться{}, // переметнуться в лагерь противника
rus_verbs:разносить{}, // разносить в щепки
rus_verbs:осыпаться{}, // осыпаться в холода
rus_verbs:попроситься{}, // попроситься в туалет
rus_verbs:уязвить{}, // уязвить в сердце
rus_verbs:перетащить{}, // перетащить в дом
rus_verbs:закутаться{}, // закутаться в плед
// rus_verbs:упаковать{}, // упаковать в бумагу
инфинитив:тикать{ aux stress="тик^ать" }, глагол:тикать{ aux stress="тик^ать" }, // тикать в крепость
rus_verbs:хихикать{}, // хихикать в кулачок
rus_verbs:объединить{}, // объединить в сеть
инфинитив:слетать{ вид:соверш }, глагол:слетать{ вид:соверш }, // слетать в Калифорнию
деепричастие:слетав{},
rus_verbs:заползти{}, // заползти в норку
rus_verbs:перерасти{}, // перерасти в крупную аферу
rus_verbs:списать{}, // списать в утиль
rus_verbs:просачиваться{}, // просачиваться в бункер
rus_verbs:пускаться{}, // пускаться в погоню
rus_verbs:согревать{}, // согревать в мороз
rus_verbs:наливаться{}, // наливаться в емкость
rus_verbs:унестись{}, // унестись в небо
rus_verbs:зашвырнуть{}, // зашвырнуть в шкаф
rus_verbs:сигануть{}, // сигануть в воду
rus_verbs:окунуть{}, // окунуть в ледяную воду
rus_verbs:просочиться{}, // просочиться в сапог
rus_verbs:соваться{}, // соваться в толпу
rus_verbs:протолкаться{}, // протолкаться в гардероб
rus_verbs:заложить{}, // заложить в ломбард
rus_verbs:перекатить{}, // перекатить в сарай
rus_verbs:поставлять{}, // поставлять в Китай
rus_verbs:залезать{}, // залезать в долги
rus_verbs:отлучаться{}, // отлучаться в туалет
rus_verbs:сбиваться{}, // сбиваться в кучу
rus_verbs:зарыть{}, // зарыть в землю
rus_verbs:засадить{}, // засадить в тело
rus_verbs:прошмыгнуть{}, // прошмыгнуть в дверь
rus_verbs:переставить{}, // переставить в шкаф
rus_verbs:отчалить{}, // отчалить в плавание
rus_verbs:набираться{}, // набираться в команду
rus_verbs:лягнуть{}, // лягнуть в живот
rus_verbs:притворить{}, // притворить в жизнь
rus_verbs:проковылять{}, // проковылять в гардероб
rus_verbs:прикатить{}, // прикатить в гараж
rus_verbs:залететь{}, // залететь в окно
rus_verbs:переделать{}, // переделать в мопед
rus_verbs:протащить{}, // протащить в совет
rus_verbs:обмакнуть{}, // обмакнуть в воду
rus_verbs:отклоняться{}, // отклоняться в сторону
rus_verbs:запихать{}, // запихать в пакет
rus_verbs:избирать{}, // избирать в совет
rus_verbs:загрузить{}, // загрузить в буфер
rus_verbs:уплывать{}, // уплывать в Париж
rus_verbs:забивать{}, // забивать в мерзлоту
rus_verbs:потыкать{}, // потыкать в безжизненную тушу
rus_verbs:съезжаться{}, // съезжаться в санаторий
rus_verbs:залепить{}, // залепить в рыло
rus_verbs:набиться{}, // набиться в карманы
rus_verbs:уползти{}, // уползти в нору
rus_verbs:упрятать{}, // упрятать в камеру
rus_verbs:переместить{}, // переместить в камеру анабиоза
rus_verbs:закрасться{}, // закрасться в душу
rus_verbs:сместиться{}, // сместиться в инфракрасную область
rus_verbs:запускать{}, // запускать в серию
rus_verbs:потрусить{}, // потрусить в чащобу
rus_verbs:забрасывать{}, // забрасывать в чистую воду
rus_verbs:переселить{}, // переселить в отдаленную деревню
rus_verbs:переезжать{}, // переезжать в новую квартиру
rus_verbs:приподнимать{}, // приподнимать в воздух
rus_verbs:добавиться{}, // добавиться в конец очереди
rus_verbs:убыть{}, // убыть в часть
rus_verbs:передвигать{}, // передвигать в соседнюю клетку
rus_verbs:добавляться{}, // добавляться в очередь
rus_verbs:дописать{}, // дописать в перечень
rus_verbs:записываться{}, // записываться в кружок
rus_verbs:продаться{}, // продаться в кредитное рабство
rus_verbs:переписывать{}, // переписывать в тетрадку
rus_verbs:заплыть{}, // заплыть в территориальные воды
инфинитив:пописать{ aux stress="поп^исать" }, инфинитив:пописать{ aux stress="попис^ать" }, // пописать в горшок
глагол:пописать{ aux stress="поп^исать" }, глагол:пописать{ aux stress="попис^ать" },
rus_verbs:отбирать{}, // отбирать в гвардию
rus_verbs:нашептывать{}, // нашептывать в микрофон
rus_verbs:ковылять{}, // ковылять в стойло
rus_verbs:прилетать{}, // прилетать в Париж
rus_verbs:пролиться{}, // пролиться в канализацию
rus_verbs:запищать{}, // запищать в микрофон
rus_verbs:подвезти{}, // подвезти в больницу
rus_verbs:припереться{}, // припереться в театр
rus_verbs:утечь{}, // утечь в сеть
rus_verbs:прорываться{}, // прорываться в буфет
rus_verbs:увозить{}, // увозить в ремонт
rus_verbs:съедать{}, // съедать в обед
rus_verbs:просунуться{}, // просунуться в дверь
rus_verbs:перенестись{}, // перенестись в прошлое
rus_verbs:завезти{}, // завезти в магазин
rus_verbs:проложить{}, // проложить в деревню
rus_verbs:объединяться{}, // объединяться в профсоюз
rus_verbs:развиться{}, // развиться в бабочку
rus_verbs:засеменить{}, // засеменить в кабинку
rus_verbs:скатываться{}, // скатываться в яму
rus_verbs:завозиться{}, // завозиться в магазин
rus_verbs:нанимать{}, // нанимать в рейс
rus_verbs:поспеть{}, // поспеть в класс
rus_verbs:кидаться{}, // кинаться в крайности
rus_verbs:поспевать{}, // поспевать в оперу
rus_verbs:обернуть{}, // обернуть в фольгу
rus_verbs:обратиться{}, // обратиться в прокуратуру
rus_verbs:истолковать{}, // истолковать в свою пользу
rus_verbs:таращиться{}, // таращиться в дисплей
rus_verbs:прыснуть{}, // прыснуть в кулачок
rus_verbs:загнуть{}, // загнуть в другую сторону
rus_verbs:раздать{}, // раздать в разные руки
rus_verbs:назначить{}, // назначить в приемную комиссию
rus_verbs:кидать{}, // кидать в кусты
rus_verbs:увлекать{}, // увлекать в лес
rus_verbs:переселиться{}, // переселиться в чужое тело
rus_verbs:присылать{}, // присылать в город
rus_verbs:уплыть{}, // уплыть в Европу
rus_verbs:запричитать{}, // запричитать в полный голос
rus_verbs:утащить{}, // утащить в логово
rus_verbs:завернуться{}, // завернуться в плед
rus_verbs:заносить{}, // заносить в блокнот
rus_verbs:пятиться{}, // пятиться в дом
rus_verbs:наведываться{}, // наведываться в больницу
rus_verbs:нырять{}, // нырять в прорубь
rus_verbs:зачастить{}, // зачастить в бар
rus_verbs:назначаться{}, // назначается в комиссию
rus_verbs:мотаться{}, // мотаться в областной центр
rus_verbs:разыграть{}, // разыграть в карты
rus_verbs:пропищать{}, // пропищать в микрофон
rus_verbs:пихнуть{}, // пихнуть в бок
rus_verbs:эмигрировать{}, // эмигрировать в Канаду
rus_verbs:подключить{}, // подключить в сеть
rus_verbs:упереть{}, // упереть в фундамент
rus_verbs:уплатить{}, // уплатить в кассу
rus_verbs:потащиться{}, // потащиться в медпункт
rus_verbs:пригнать{}, // пригнать в стойло
rus_verbs:оттеснить{}, // оттеснить в фойе
rus_verbs:стучаться{}, // стучаться в ворота
rus_verbs:перечислить{}, // перечислить в фонд
rus_verbs:сомкнуть{}, // сомкнуть в круг
rus_verbs:закачаться{}, // закачаться в резервуар
rus_verbs:кольнуть{}, // кольнуть в бок
rus_verbs:накрениться{}, // накрениться в сторону берега
rus_verbs:подвинуться{}, // подвинуться в другую сторону
rus_verbs:разнести{}, // разнести в клочья
rus_verbs:отливать{}, // отливать в форму
rus_verbs:подкинуть{}, // подкинуть в карман
rus_verbs:уводить{}, // уводить в кабинет
rus_verbs:ускакать{}, // ускакать в школу
rus_verbs:ударять{}, // ударять в барабаны
rus_verbs:даться{}, // даться в руки
rus_verbs:поцеловаться{}, // поцеловаться в губы
rus_verbs:посветить{}, // посветить в подвал
rus_verbs:тыкать{}, // тыкать в арбуз
rus_verbs:соединяться{}, // соединяться в кольцо
rus_verbs:растянуть{}, // растянуть в тонкую ниточку
rus_verbs:побросать{}, // побросать в пыль
rus_verbs:стукнуться{}, // стукнуться в закрытую дверь
rus_verbs:проигрывать{}, // проигрывать в теннис
rus_verbs:дунуть{}, // дунуть в трубочку
rus_verbs:улетать{}, // улетать в Париж
rus_verbs:переводиться{}, // переводиться в филиал
rus_verbs:окунуться{}, // окунуться в водоворот событий
rus_verbs:попрятаться{}, // попрятаться в норы
rus_verbs:перевезти{}, // перевезти в соседнюю палату
rus_verbs:топать{}, // топать в школу
rus_verbs:относить{}, // относить в помещение
rus_verbs:укладывать{}, // укладывать в стопку
rus_verbs:укатить{}, // укатил в турне
rus_verbs:убирать{}, // убирать в сумку
rus_verbs:помалкивать{}, // помалкивать в тряпочку
rus_verbs:ронять{}, // ронять в грязь
rus_verbs:глазеть{}, // глазеть в бинокль
rus_verbs:преобразиться{}, // преобразиться в другого человека
rus_verbs:запрыгнуть{}, // запрыгнуть в поезд
rus_verbs:сгодиться{}, // сгодиться в суп
rus_verbs:проползти{}, // проползти в нору
rus_verbs:забираться{}, // забираться в коляску
rus_verbs:сбежаться{}, // сбежались в класс
rus_verbs:закатиться{}, // закатиться в угол
rus_verbs:плевать{}, // плевать в душу
rus_verbs:поиграть{}, // поиграть в демократию
rus_verbs:кануть{}, // кануть в небытие
rus_verbs:опаздывать{}, // опаздывать в школу
rus_verbs:отползти{}, // отползти в сторону
rus_verbs:стекаться{}, // стекаться в отстойник
rus_verbs:запихнуть{}, // запихнуть в пакет
rus_verbs:вышвырнуть{}, // вышвырнуть в коридор
rus_verbs:связываться{}, // связываться в плотный узел
rus_verbs:затолкать{}, // затолкать в ухо
rus_verbs:скрутить{}, // скрутить в трубочку
rus_verbs:сворачивать{}, // сворачивать в трубочку
rus_verbs:сплестись{}, // сплестись в узел
rus_verbs:заскочить{}, // заскочить в кабинет
rus_verbs:проваливаться{}, // проваливаться в сон
rus_verbs:уверовать{}, // уверовать в свою безнаказанность
rus_verbs:переписать{}, // переписать в тетрадку
rus_verbs:переноситься{}, // переноситься в мир фантазий
rus_verbs:заводить{}, // заводить в помещение
rus_verbs:сунуться{}, // сунуться в аудиторию
rus_verbs:устраиваться{}, // устраиваться в автомастерскую
rus_verbs:пропускать{}, // пропускать в зал
инфинитив:сбегать{ вид:несоверш }, инфинитив:сбегать{ вид:соверш }, // сбегать в кино
глагол:сбегать{ вид:несоверш }, глагол:сбегать{ вид:соверш },
деепричастие:сбегая{}, деепричастие:сбегав{},
rus_verbs:прибегать{}, // прибегать в школу
rus_verbs:съездить{}, // съездить в лес
rus_verbs:захлопать{}, // захлопать в ладошки
rus_verbs:опрокинуться{}, // опрокинуться в грязь
инфинитив:насыпать{ вид:несоверш }, инфинитив:насыпать{ вид:соверш }, // насыпать в стакан
глагол:насыпать{ вид:несоверш }, глагол:насыпать{ вид:соверш },
деепричастие:насыпая{}, деепричастие:насыпав{},
rus_verbs:употреблять{}, // употреблять в пищу
rus_verbs:приводиться{}, // приводиться в действие
rus_verbs:пристроить{}, // пристроить в надежные руки
rus_verbs:юркнуть{}, // юркнуть в нору
rus_verbs:объединиться{}, // объединиться в банду
rus_verbs:сажать{}, // сажать в одиночку
rus_verbs:соединить{}, // соединить в кольцо
rus_verbs:забрести{}, // забрести в кафешку
rus_verbs:свернуться{}, // свернуться в клубочек
rus_verbs:пересесть{}, // пересесть в другой автобус
rus_verbs:постучаться{}, // постучаться в дверцу
rus_verbs:соединять{}, // соединять в кольцо
rus_verbs:приволочь{}, // приволочь в коморку
rus_verbs:смахивать{}, // смахивать в ящик стола
rus_verbs:забежать{}, // забежать в помещение
rus_verbs:целиться{}, // целиться в беглеца
rus_verbs:прокрасться{}, // прокрасться в хранилище
rus_verbs:заковылять{}, // заковылять в травтамологию
rus_verbs:прискакать{}, // прискакать в стойло
rus_verbs:колотить{}, // колотить в дверь
rus_verbs:смотреться{}, // смотреться в зеркало
rus_verbs:подложить{}, // подложить в салон
rus_verbs:пущать{}, // пущать в королевские покои
rus_verbs:согнуть{}, // согнуть в дугу
rus_verbs:забарабанить{}, // забарабанить в дверь
rus_verbs:отклонить{}, // отклонить в сторону посадочной полосы
rus_verbs:убраться{}, // убраться в специальную нишу
rus_verbs:насмотреться{}, // насмотреться в зеркало
rus_verbs:чмокнуть{}, // чмокнуть в щечку
rus_verbs:усмехаться{}, // усмехаться в бороду
rus_verbs:передвинуть{}, // передвинуть в конец очереди
rus_verbs:допускаться{}, // допускаться в опочивальню
rus_verbs:задвинуть{}, // задвинуть в дальний угол
rus_verbs:отправлять{}, // отправлять в центр
rus_verbs:сбрасывать{}, // сбрасывать в жерло
rus_verbs:расстреливать{}, // расстреливать в момент обнаружения
rus_verbs:заволочь{}, // заволочь в закуток
rus_verbs:пролить{}, // пролить в воду
rus_verbs:зарыться{}, // зарыться в сено
rus_verbs:переливаться{}, // переливаться в емкость
rus_verbs:затащить{}, // затащить в клуб
rus_verbs:перебежать{}, // перебежать в лагерь врагов
rus_verbs:одеть{}, // одеть в новое платье
инфинитив:задвигаться{ вид:несоверш }, глагол:задвигаться{ вид:несоверш }, // задвигаться в нишу
деепричастие:задвигаясь{},
rus_verbs:клюнуть{}, // клюнуть в темечко
rus_verbs:наливать{}, // наливать в кружку
rus_verbs:пролезть{}, // пролезть в ушко
rus_verbs:откладывать{}, // откладывать в ящик
rus_verbs:протянуться{}, // протянуться в соседний дом
rus_verbs:шлепнуться{}, // шлепнуться лицом в грязь
rus_verbs:устанавливать{}, // устанавливать в машину
rus_verbs:употребляться{}, // употребляться в пищу
rus_verbs:переключиться{}, // переключиться в реверсный режим
rus_verbs:пискнуть{}, // пискнуть в микрофон
rus_verbs:заявиться{}, // заявиться в класс
rus_verbs:налиться{}, // налиться в стакан
rus_verbs:заливать{}, // заливать в бак
rus_verbs:ставиться{}, // ставиться в очередь
инфинитив:писаться{ aux stress="п^исаться" }, глагол:писаться{ aux stress="п^исаться" }, // писаться в штаны
деепричастие:писаясь{},
rus_verbs:целоваться{}, // целоваться в губы
rus_verbs:наносить{}, // наносить в область сердца
rus_verbs:посмеяться{}, // посмеяться в кулачок
rus_verbs:употребить{}, // употребить в пищу
rus_verbs:прорваться{}, // прорваться в столовую
rus_verbs:укладываться{}, // укладываться в ровные стопки
rus_verbs:пробиться{}, // пробиться в финал
rus_verbs:забить{}, // забить в землю
rus_verbs:переложить{}, // переложить в другой карман
rus_verbs:опускать{}, // опускать в свежевырытую могилу
rus_verbs:поторопиться{}, // поторопиться в школу
rus_verbs:сдвинуться{}, // сдвинуться в сторону
rus_verbs:капать{}, // капать в смесь
rus_verbs:погружаться{}, // погружаться во тьму
rus_verbs:направлять{}, // направлять в кабинку
rus_verbs:погрузить{}, // погрузить во тьму
rus_verbs:примчаться{}, // примчаться в школу
rus_verbs:упираться{}, // упираться в дверь
rus_verbs:удаляться{}, // удаляться в комнату совещаний
rus_verbs:ткнуться{}, // ткнуться в окошко
rus_verbs:убегать{}, // убегать в чащу
rus_verbs:соединиться{}, // соединиться в необычную пространственную фигуру
rus_verbs:наговорить{}, // наговорить в микрофон
rus_verbs:переносить{}, // переносить в дом
rus_verbs:прилечь{}, // прилечь в кроватку
rus_verbs:поворачивать{}, // поворачивать в обратную сторону
rus_verbs:проскочить{}, // проскочить в щель
rus_verbs:совать{}, // совать в духовку
rus_verbs:переодеться{}, // переодеться в чистую одежду
rus_verbs:порвать{}, // порвать в лоскуты
rus_verbs:завязать{}, // завязать в бараний рог
rus_verbs:съехать{}, // съехать в кювет
rus_verbs:литься{}, // литься в канистру
rus_verbs:уклониться{}, // уклониться в левую сторону
rus_verbs:смахнуть{}, // смахнуть в мусорное ведро
rus_verbs:спускать{}, // спускать в шахту
rus_verbs:плеснуть{}, // плеснуть в воду
rus_verbs:подуть{}, // подуть в угольки
rus_verbs:набирать{}, // набирать в команду
rus_verbs:хлопать{}, // хлопать в ладошки
rus_verbs:ранить{}, // ранить в самое сердце
rus_verbs:посматривать{}, // посматривать в иллюминатор
rus_verbs:превращать{}, // превращать воду в вино
rus_verbs:толкать{}, // толкать в пучину
rus_verbs:отбыть{}, // отбыть в расположение части
rus_verbs:сгрести{}, // сгрести в карман
rus_verbs:удрать{}, // удрать в тайгу
rus_verbs:пристроиться{}, // пристроиться в хорошую фирму
rus_verbs:сбиться{}, // сбиться в плотную группу
rus_verbs:заключать{}, // заключать в объятия
rus_verbs:отпускать{}, // отпускать в поход
rus_verbs:устремить{}, // устремить взгляд в будущее
rus_verbs:обронить{}, // обронить в траву
rus_verbs:сливаться{}, // сливаться в речку
rus_verbs:стекать{}, // стекать в канаву
rus_verbs:свалить{}, // свалить в кучу
rus_verbs:подтянуть{}, // подтянуть в кабину
rus_verbs:скатиться{}, // скатиться в канаву
rus_verbs:проскользнуть{}, // проскользнуть в приоткрытую дверь
rus_verbs:заторопиться{}, // заторопиться в буфет
rus_verbs:протиснуться{}, // протиснуться в центр толпы
rus_verbs:прятать{}, // прятать в укромненькое местечко
rus_verbs:пропеть{}, // пропеть в микрофон
rus_verbs:углубиться{}, // углубиться в джунгли
rus_verbs:сползти{}, // сползти в яму
rus_verbs:записывать{}, // записывать в память
rus_verbs:расстрелять{}, // расстрелять в упор (наречный оборот В УПОР)
rus_verbs:колотиться{}, // колотиться в дверь
rus_verbs:просунуть{}, // просунуть в отверстие
rus_verbs:провожать{}, // провожать в армию
rus_verbs:катить{}, // катить в гараж
rus_verbs:поражать{}, // поражать в самое сердце
rus_verbs:отлететь{}, // отлететь в дальний угол
rus_verbs:закинуть{}, // закинуть в речку
rus_verbs:катиться{}, // катиться в пропасть
rus_verbs:забросить{}, // забросить в дальний угол
rus_verbs:отвезти{}, // отвезти в лагерь
rus_verbs:втопить{}, // втопить педаль в пол
rus_verbs:втапливать{}, // втапливать педать в пол
rus_verbs:утопить{}, // утопить кнопку в панель
rus_verbs:напасть{}, // В Пекине участники антияпонских протестов напали на машину посла США
rus_verbs:нанять{}, // Босс нанял в службу поддержки еще несколько девушек
rus_verbs:переводить{}, // переводить в устойчивую к перегреву форму
rus_verbs:баллотировать{}, // претендент был баллотирован в жюри (баллотирован?)
rus_verbs:вбухать{}, // Власти вбухали в этой проект много денег
rus_verbs:вбухивать{}, // Власти вбухивают в этот проект очень много денег
rus_verbs:поскакать{}, // поскакать в атаку
rus_verbs:прицелиться{}, // прицелиться в бегущего зайца
rus_verbs:прыгать{}, // прыгать в кровать
rus_verbs:приглашать{}, // приглашать в дом
rus_verbs:понестись{}, // понестись в ворота
rus_verbs:заехать{}, // заехать в гаражный бокс
rus_verbs:опускаться{}, // опускаться в бездну
rus_verbs:переехать{}, // переехать в коттедж
rus_verbs:поместить{}, // поместить в карантин
rus_verbs:ползти{}, // ползти в нору
rus_verbs:добавлять{}, // добавлять в корзину
rus_verbs:уткнуться{}, // уткнуться в подушку
rus_verbs:продавать{}, // продавать в рабство
rus_verbs:спрятаться{}, // Белка спрячется в дупло.
rus_verbs:врисовывать{}, // врисовывать новый персонаж в анимацию
rus_verbs:воткнуть{}, // воткни вилку в розетку
rus_verbs:нести{}, // нести в больницу
rus_verbs:воткнуться{}, // вилка воткнулась в сочную котлетку
rus_verbs:впаивать{}, // впаивать деталь в плату
rus_verbs:впаиваться{}, // деталь впаивается в плату
rus_verbs:впархивать{}, // впархивать в помещение
rus_verbs:впаять{}, // впаять деталь в плату
rus_verbs:впендюривать{}, // впендюривать штукенцию в агрегат
rus_verbs:впендюрить{}, // впендюрить штукенцию в агрегат
rus_verbs:вперивать{}, // вперивать взгляд в экран
rus_verbs:впериваться{}, // впериваться в экран
rus_verbs:вперить{}, // вперить взгляд в экран
rus_verbs:впериться{}, // впериться в экран
rus_verbs:вперять{}, // вперять взгляд в экран
rus_verbs:вперяться{}, // вперяться в экран
rus_verbs:впечатать{}, // впечатать текст в первую главу
rus_verbs:впечататься{}, // впечататься в стену
rus_verbs:впечатывать{}, // впечатывать текст в первую главу
rus_verbs:впечатываться{}, // впечатываться в стену
rus_verbs:впиваться{}, // Хищник впивается в жертву мощными зубами
rus_verbs:впитаться{}, // Жидкость впиталась в ткань
rus_verbs:впитываться{}, // Жидкость впитывается в ткань
rus_verbs:впихивать{}, // Мама впихивает в сумку кусок колбасы
rus_verbs:впихиваться{}, // Кусок колбасы впихивается в сумку
rus_verbs:впихнуть{}, // Мама впихнула кастрюлю в холодильник
rus_verbs:впихнуться{}, // Кастрюля впихнулась в холодильник
rus_verbs:вплавиться{}, // Провод вплавился в плату
rus_verbs:вплеснуть{}, // вплеснуть краситель в бак
rus_verbs:вплести{}, // вплести ленту в волосы
rus_verbs:вплестись{}, // вплестись в волосы
rus_verbs:вплетать{}, // вплетать ленты в волосы
rus_verbs:вплывать{}, // корабль вплывает в порт
rus_verbs:вплыть{}, // яхта вплыла в бухту
rus_verbs:вползать{}, // дракон вползает в пещеру
rus_verbs:вползти{}, // дракон вполз в свою пещеру
rus_verbs:впорхнуть{}, // бабочка впорхнула в окно
rus_verbs:впрессовать{}, // впрессовать деталь в плиту
rus_verbs:впрессоваться{}, // впрессоваться в плиту
rus_verbs:впрессовывать{}, // впрессовывать деталь в плиту
rus_verbs:впрессовываться{}, // впрессовываться в плиту
rus_verbs:впрыгивать{}, // Пассажир впрыгивает в вагон
rus_verbs:впрыгнуть{}, // Пассажир впрыгнул в вагон
rus_verbs:впрыскивать{}, // Форсунка впрыскивает топливо в цилиндр
rus_verbs:впрыскиваться{}, // Топливо впрыскивается форсункой в цилиндр
rus_verbs:впрыснуть{}, // Форсунка впрыснула топливную смесь в камеру сгорания
rus_verbs:впрягать{}, // впрягать лошадь в телегу
rus_verbs:впрягаться{}, // впрягаться в работу
rus_verbs:впрячь{}, // впрячь лошадь в телегу
rus_verbs:впрячься{}, // впрячься в работу
rus_verbs:впускать{}, // впускать посетителей в музей
rus_verbs:впускаться{}, // впускаться в помещение
rus_verbs:впустить{}, // впустить посетителей в музей
rus_verbs:впутать{}, // впутать кого-то во что-то
rus_verbs:впутаться{}, // впутаться во что-то
rus_verbs:впутывать{}, // впутывать кого-то во что-то
rus_verbs:впутываться{}, // впутываться во что-то
rus_verbs:врабатываться{}, // врабатываться в режим
rus_verbs:вработаться{}, // вработаться в режим
rus_verbs:врастать{}, // врастать в кожу
rus_verbs:врасти{}, // врасти в кожу
инфинитив:врезать{ вид:несоверш }, // врезать замок в дверь
инфинитив:врезать{ вид:соверш },
глагол:врезать{ вид:несоверш },
глагол:врезать{ вид:соверш },
деепричастие:врезая{},
деепричастие:врезав{},
прилагательное:врезанный{},
инфинитив:врезаться{ вид:несоверш }, // врезаться в стену
инфинитив:врезаться{ вид:соверш },
глагол:врезаться{ вид:несоверш },
деепричастие:врезаясь{},
деепричастие:врезавшись{},
rus_verbs:врубить{}, // врубить в нагрузку
rus_verbs:врываться{}, // врываться в здание
rus_verbs:закачивать{}, // Насос закачивает топливо в бак
rus_verbs:ввезти{}, // Предприятие ввезло товар в страну
rus_verbs:вверстать{}, // Дизайнер вверстал блок в страницу
rus_verbs:вверстывать{}, // Дизайнер с трудом вверстывает блоки в страницу
rus_verbs:вверстываться{}, // Блок тяжело вверстывается в эту страницу
rus_verbs:ввивать{}, // Женщина ввивает полоску в косу
rus_verbs:вволакиваться{}, // Пойманная мышь вволакивается котиком в дом
rus_verbs:вволочь{}, // Кот вволок в дом пойманную крысу
rus_verbs:вдергивать{}, // приспособление вдергивает нитку в игольное ушко
rus_verbs:вдернуть{}, // приспособление вдернуло нитку в игольное ушко
rus_verbs:вдувать{}, // Челоек вдувает воздух в легкие второго человека
rus_verbs:вдуваться{}, // Воздух вдувается в легкие человека
rus_verbs:вламываться{}, // Полиция вламывается в квартиру
rus_verbs:вовлекаться{}, // трудные подростки вовлекаются в занятие спортом
rus_verbs:вовлечь{}, // вовлечь трудных подростков в занятие спортом
rus_verbs:вовлечься{}, // вовлечься в занятие спортом
rus_verbs:спуститься{}, // спуститься в подвал
rus_verbs:спускаться{}, // спускаться в подвал
rus_verbs:отправляться{}, // отправляться в дальнее плавание
инфинитив:эмитировать{ вид:соверш }, // Поверхность эмитирует электроны в пространство
инфинитив:эмитировать{ вид:несоверш },
глагол:эмитировать{ вид:соверш },
глагол:эмитировать{ вид:несоверш },
деепричастие:эмитируя{},
деепричастие:эмитировав{},
прилагательное:эмитировавший{ вид:несоверш },
// прилагательное:эмитировавший{ вид:соверш },
прилагательное:эмитирующий{},
прилагательное:эмитируемый{},
прилагательное:эмитированный{},
инфинитив:этапировать{вид:несоверш}, // Преступника этапировали в колонию
инфинитив:этапировать{вид:соверш},
глагол:этапировать{вид:несоверш},
глагол:этапировать{вид:соверш},
деепричастие:этапируя{},
прилагательное:этапируемый{},
прилагательное:этапированный{},
rus_verbs:этапироваться{}, // Преступники этапируются в колонию
rus_verbs:баллотироваться{}, // они баллотировались в жюри
rus_verbs:бежать{}, // Олигарх с семьей любовницы бежал в другую страну
rus_verbs:бросать{}, // Они бросали в фонтан медные монетки
rus_verbs:бросаться{}, // Дети бросались в воду с моста
rus_verbs:бросить{}, // Он бросил в фонтан медную монетку
rus_verbs:броситься{}, // самоубийца бросился с моста в воду
rus_verbs:превратить{}, // Найден белок, который превратит человека в супергероя
rus_verbs:буксировать{}, // Буксир буксирует танкер в порт
rus_verbs:буксироваться{}, // Сухогруз буксируется в порт
rus_verbs:вбегать{}, // Курьер вбегает в дверь
rus_verbs:вбежать{}, // Курьер вбежал в дверь
rus_verbs:вбетонировать{}, // Опора была вбетонирована в пол
rus_verbs:вбивать{}, // Мастер вбивает штырь в плиту
rus_verbs:вбиваться{}, // Штырь вбивается в плиту
rus_verbs:вбирать{}, // Вата вбирает в себя влагу
rus_verbs:вбить{}, // Ученик вбил в доску маленький гвоздь
rus_verbs:вбрасывать{}, // Арбитр вбрасывает мяч в игру
rus_verbs:вбрасываться{}, // Мяч вбрасывается в игру
rus_verbs:вбросить{}, // Судья вбросил мяч в игру
rus_verbs:вбуравиться{}, // Сверло вбуравилось в бетон
rus_verbs:вбуравливаться{}, // Сверло вбуравливается в бетон
rus_verbs:вбухиваться{}, // Много денег вбухиваются в этот проект
rus_verbs:вваливаться{}, // Человек вваливается в кабинет врача
rus_verbs:ввалить{}, // Грузчики ввалили мешок в квартиру
rus_verbs:ввалиться{}, // Человек ввалился в кабинет терапевта
rus_verbs:вваривать{}, // Робот вваривает арматурину в плиту
rus_verbs:ввариваться{}, // Арматура вваривается в плиту
rus_verbs:вварить{}, // Робот вварил арматурину в плиту
rus_verbs:влезть{}, // Предприятие ввезло товар в страну
rus_verbs:ввернуть{}, // Вверни новую лампочку в люстру
rus_verbs:ввернуться{}, // Лампочка легко ввернулась в патрон
rus_verbs:ввертывать{}, // Электрик ввертывает лампочку в патрон
rus_verbs:ввертываться{}, // Лампочка легко ввертывается в патрон
rus_verbs:вверять{}, // Пациент вверяет свою жизнь в руки врача
rus_verbs:вверяться{}, // Пациент вверяется в руки врача
rus_verbs:ввести{}, // Агенство ввело своего представителя в совет директоров
rus_verbs:ввиваться{}, // полоска ввивается в косу
rus_verbs:ввинтить{}, // Отвертка ввинтила шуруп в дерево
rus_verbs:ввинтиться{}, // Шуруп ввинтился в дерево
rus_verbs:ввинчивать{}, // Рука ввинчивает саморез в стену
rus_verbs:ввинчиваться{}, // Саморез ввинчивается в стену
rus_verbs:вводить{}, // Агенство вводит своего представителя в совет директоров
rus_verbs:вводиться{}, // Представитель агенства вводится в совет директоров
// rus_verbs:ввозить{}, // Фирма ввозит в страну станки и сырье
rus_verbs:ввозиться{}, // Станки и сырье ввозятся в страну
rus_verbs:вволакивать{}, // Пойманная мышь вволакивается котиком в дом
rus_verbs:вворачивать{}, // Электрик вворачивает новую лампочку в патрон
rus_verbs:вворачиваться{}, // Новая лампочка легко вворачивается в патрон
rus_verbs:ввязаться{}, // Разведрота ввязалась в бой
rus_verbs:ввязываться{}, // Передовые части ввязываются в бой
rus_verbs:вглядеться{}, // Охранник вгляделся в темный коридор
rus_verbs:вглядываться{}, // Охранник внимательно вглядывается в монитор
rus_verbs:вгонять{}, // Эта музыка вгоняет меня в депрессию
rus_verbs:вгрызаться{}, // Зонд вгрызается в поверхность астероида
rus_verbs:вгрызться{}, // Зонд вгрызся в поверхность астероида
rus_verbs:вдаваться{}, // Вы не должны вдаваться в юридические детали
rus_verbs:вдвигать{}, // Робот вдвигает контейнер в ячейку
rus_verbs:вдвигаться{}, // Контейнер вдвигается в ячейку
rus_verbs:вдвинуть{}, // манипулятор вдвинул деталь в печь
rus_verbs:вдвинуться{}, // деталь вдвинулась в печь
rus_verbs:вдевать{}, // портниха быстро вдевает нитку в иголку
rus_verbs:вдеваться{}, // нитка быстро вдевается в игольное ушко
rus_verbs:вдеть{}, // портниха быстро вдела нитку в игольное ушко
rus_verbs:вдеться{}, // нитка быстро вделась в игольное ушко
rus_verbs:вделать{}, // мастер вделал розетку в стену
rus_verbs:вделывать{}, // мастер вделывает выключатель в стену
rus_verbs:вделываться{}, // кронштейн вделывается в стену
rus_verbs:вдергиваться{}, // нитка легко вдергивается в игольное ушко
rus_verbs:вдернуться{}, // нитка легко вдернулась в игольное ушко
rus_verbs:вдолбить{}, // Американцы обещали вдолбить страну в каменный век
rus_verbs:вдумываться{}, // Мальчик обычно не вдумывался в сюжет фильмов
rus_verbs:вдыхать{}, // мы вдыхаем в себя весь этот смог
rus_verbs:вдыхаться{}, // Весь этот смог вдыхается в легкие
rus_verbs:вернуть{}, // Книгу надо вернуть в библиотеку
rus_verbs:вернуться{}, // Дети вернулись в библиотеку
rus_verbs:вжаться{}, // Водитель вжался в кресло
rus_verbs:вживаться{}, // Актер вживается в новую роль
rus_verbs:вживить{}, // Врачи вживили стимулятор в тело пациента
rus_verbs:вживиться{}, // Стимулятор вживился в тело пациента
rus_verbs:вживлять{}, // Врачи вживляют стимулятор в тело пациента
rus_verbs:вживляться{}, // Стимулятор вживляется в тело
rus_verbs:вжиматься{}, // Видитель инстинктивно вжимается в кресло
rus_verbs:вжиться{}, // Актер вжился в свою новую роль
rus_verbs:взвиваться{}, // Воздушный шарик взвивается в небо
rus_verbs:взвинтить{}, // Кризис взвинтил цены в небо
rus_verbs:взвинтиться{}, // Цены взвинтились в небо
rus_verbs:взвинчивать{}, // Кризис взвинчивает цены в небо
rus_verbs:взвинчиваться{}, // Цены взвинчиваются в небо
rus_verbs:взвиться{}, // Шарики взвились в небо
rus_verbs:взлетать{}, // Экспериментальный аппарат взлетает в воздух
rus_verbs:взлететь{}, // Экспериментальный аппарат взлетел в небо
rus_verbs:взмывать{}, // шарики взмывают в небо
rus_verbs:взмыть{}, // Шарики взмыли в небо
rus_verbs:вильнуть{}, // Машина вильнула в левую сторону
rus_verbs:вкалывать{}, // Медсестра вкалывает иглу в вену
rus_verbs:вкалываться{}, // Игла вкалываться прямо в вену
rus_verbs:вкапывать{}, // рабочий вкапывает сваю в землю
rus_verbs:вкапываться{}, // Свая вкапывается в землю
rus_verbs:вкатить{}, // рабочие вкатили бочку в гараж
rus_verbs:вкатиться{}, // машина вкатилась в гараж
rus_verbs:вкатывать{}, // рабочик вкатывают бочку в гараж
rus_verbs:вкатываться{}, // машина вкатывается в гараж
rus_verbs:вкачать{}, // Механики вкачали в бак много топлива
rus_verbs:вкачивать{}, // Насос вкачивает топливо в бак
rus_verbs:вкачиваться{}, // Топливо вкачивается в бак
rus_verbs:вкидать{}, // Манипулятор вкидал груз в контейнер
rus_verbs:вкидывать{}, // Манипулятор вкидывает груз в контейнер
rus_verbs:вкидываться{}, // Груз вкидывается в контейнер
rus_verbs:вкладывать{}, // Инвестор вкладывает деньги в акции
rus_verbs:вкладываться{}, // Инвестор вкладывается в акции
rus_verbs:вклеивать{}, // Мальчик вклеивает картинку в тетрадь
rus_verbs:вклеиваться{}, // Картинка вклеивается в тетрадь
rus_verbs:вклеить{}, // Мальчик вклеил картинку в тетрадь
rus_verbs:вклеиться{}, // Картинка вклеилась в тетрадь
rus_verbs:вклепать{}, // Молоток вклепал заклепку в лист
rus_verbs:вклепывать{}, // Молоток вклепывает заклепку в лист
rus_verbs:вклиниваться{}, // Машина вклинивается в поток
rus_verbs:вклиниться{}, // машина вклинилась в поток
rus_verbs:включать{}, // Команда включает компьютер в сеть
rus_verbs:включаться{}, // Машина включается в глобальную сеть
rus_verbs:включить{}, // Команда включила компьютер в сеть
rus_verbs:включиться{}, // Компьютер включился в сеть
rus_verbs:вколачивать{}, // Столяр вколачивает гвоздь в доску
rus_verbs:вколачиваться{}, // Гвоздь вколачивается в доску
rus_verbs:вколотить{}, // Столяр вколотил гвоздь в доску
rus_verbs:вколоть{}, // Медсестра вколола в мышцу лекарство
rus_verbs:вкопать{}, // Рабочие вкопали сваю в землю
rus_verbs:вкрадываться{}, // Ошибка вкрадывается в расчеты
rus_verbs:вкраивать{}, // Портниха вкраивает вставку в юбку
rus_verbs:вкраиваться{}, // Вставка вкраивается в юбку
rus_verbs:вкрасться{}, // Ошибка вкралась в расчеты
rus_verbs:вкрутить{}, // Электрик вкрутил лампочку в патрон
rus_verbs:вкрутиться{}, // лампочка легко вкрутилась в патрон
rus_verbs:вкручивать{}, // Электрик вкручивает лампочку в патрон
rus_verbs:вкручиваться{}, // Лампочка легко вкручивается в патрон
rus_verbs:влазить{}, // Разъем влазит в отверствие
rus_verbs:вламывать{}, // Полиция вламывается в квартиру
rus_verbs:влетать{}, // Самолет влетает в грозовой фронт
rus_verbs:влететь{}, // Самолет влетел в грозовой фронт
rus_verbs:вливать{}, // Механик вливает масло в картер
rus_verbs:вливаться{}, // Масло вливается в картер
rus_verbs:влипать{}, // Эти неудачники постоянно влипают в разные происшествия
rus_verbs:влипнуть{}, // Эти неудачники опять влипли в неприятности
rus_verbs:влить{}, // Механик влил свежее масло в картер
rus_verbs:влиться{}, // Свежее масло влилось в бак
rus_verbs:вложить{}, // Инвесторы вложили в эти акции большие средства
rus_verbs:вложиться{}, // Инвесторы вложились в эти акции
rus_verbs:влюбиться{}, // Коля влюбился в Олю
rus_verbs:влюблять{}, // Оля постоянно влюбляла в себя мальчиков
rus_verbs:влюбляться{}, // Оля влюбляется в спортсменов
rus_verbs:вляпаться{}, // Коля вляпался в неприятность
rus_verbs:вляпываться{}, // Коля постоянно вляпывается в неприятности
rus_verbs:вменить{}, // вменить в вину
rus_verbs:вменять{}, // вменять в обязанность
rus_verbs:вмерзать{}, // Колеса вмерзают в лед
rus_verbs:вмерзнуть{}, // Колеса вмерзли в лед
rus_verbs:вмести{}, // вмести в дом
rus_verbs:вместить{}, // вместить в ёмкость
rus_verbs:вместиться{}, // Прибор не вместился в зонд
rus_verbs:вмешаться{}, // Начальник вмешался в конфликт
rus_verbs:вмешивать{}, // Не вмешивай меня в это дело
rus_verbs:вмешиваться{}, // Начальник вмешивается в переговоры
rus_verbs:вмещаться{}, // Приборы не вмещаются в корпус
rus_verbs:вминать{}, // вминать в корпус
rus_verbs:вминаться{}, // кронштейн вминается в корпус
rus_verbs:вмонтировать{}, // Конструкторы вмонтировали в корпус зонда новые приборы
rus_verbs:вмонтироваться{}, // Новые приборы легко вмонтировались в корпус зонда
rus_verbs:вмораживать{}, // Установка вмораживает сваи в грунт
rus_verbs:вмораживаться{}, // Сваи вмораживаются в грунт
rus_verbs:вморозить{}, // Установка вморозила сваи в грунт
rus_verbs:вмуровать{}, // Сейф был вмурован в стену
rus_verbs:вмуровывать{}, // вмуровывать сейф в стену
rus_verbs:вмуровываться{}, // сейф вмуровывается в бетонную стену
rus_verbs:внедрить{}, // внедрить инновацию в производство
rus_verbs:внедриться{}, // Шпион внедрился в руководство
rus_verbs:внедрять{}, // внедрять инновации в производство
rus_verbs:внедряться{}, // Шпионы внедряются в руководство
rus_verbs:внести{}, // внести коробку в дом
rus_verbs:внестись{}, // внестись в список приглашенных гостей
rus_verbs:вникать{}, // Разработчик вникает в детали задачи
rus_verbs:вникнуть{}, // Дизайнер вник в детали задачи
rus_verbs:вносить{}, // вносить новое действующее лицо в список главных героев
rus_verbs:вноситься{}, // вноситься в список главных персонажей
rus_verbs:внюхаться{}, // Пёс внюхался в ароматы леса
rus_verbs:внюхиваться{}, // Пёс внюхивается в ароматы леса
rus_verbs:вобрать{}, // вобрать в себя лучшие методы борьбы с вредителями
rus_verbs:вовлекать{}, // вовлекать трудных подростков в занятие спортом
rus_verbs:вогнать{}, // вогнал человека в тоску
rus_verbs:водворить{}, // водворить преступника в тюрьму
rus_verbs:возвернуть{}, // возвернуть в родную стихию
rus_verbs:возвернуться{}, // возвернуться в родную стихию
rus_verbs:возвести{}, // возвести число в четную степень
rus_verbs:возводить{}, // возводить число в четную степень
rus_verbs:возводиться{}, // число возводится в четную степень
rus_verbs:возвратить{}, // возвратить коров в стойло
rus_verbs:возвратиться{}, // возвратиться в родной дом
rus_verbs:возвращать{}, // возвращать коров в стойло
rus_verbs:возвращаться{}, // возвращаться в родной дом
rus_verbs:войти{}, // войти в галерею славы
rus_verbs:вонзать{}, // Коля вонзает вилку в котлету
rus_verbs:вонзаться{}, // Вилка вонзается в котлету
rus_verbs:вонзить{}, // Коля вонзил вилку в котлету
rus_verbs:вонзиться{}, // Вилка вонзилась в сочную котлету
rus_verbs:воплотить{}, // Коля воплотил свои мечты в реальность
rus_verbs:воплотиться{}, // Мечты воплотились в реальность
rus_verbs:воплощать{}, // Коля воплощает мечты в реальность
rus_verbs:воплощаться{}, // Мечты иногда воплощаются в реальность
rus_verbs:ворваться{}, // Перемены неожиданно ворвались в размеренную жизнь
rus_verbs:воспарить{}, // Душа воспарила в небо
rus_verbs:воспарять{}, // Душа воспаряет в небо
rus_verbs:врыть{}, // врыть опору в землю
rus_verbs:врыться{}, // врыться в землю
rus_verbs:всадить{}, // всадить пулю в сердце
rus_verbs:всаживать{}, // всаживать нож в бок
rus_verbs:всасывать{}, // всасывать воду в себя
rus_verbs:всасываться{}, // всасываться в ёмкость
rus_verbs:вселить{}, // вселить надежду в кого-либо
rus_verbs:вселиться{}, // вселиться в пустующее здание
rus_verbs:вселять{}, // вселять надежду в кого-то
rus_verbs:вселяться{}, // вселяться в пустующее здание
rus_verbs:вскидывать{}, // вскидывать руку в небо
rus_verbs:вскинуть{}, // вскинуть руку в небо
rus_verbs:вслушаться{}, // вслушаться в звуки
rus_verbs:вслушиваться{}, // вслушиваться в шорох
rus_verbs:всматриваться{}, // всматриваться в темноту
rus_verbs:всмотреться{}, // всмотреться в темень
rus_verbs:всовывать{}, // всовывать палец в отверстие
rus_verbs:всовываться{}, // всовываться в форточку
rus_verbs:всосать{}, // всосать жидкость в себя
rus_verbs:всосаться{}, // всосаться в кожу
rus_verbs:вставить{}, // вставить ключ в замок
rus_verbs:вставлять{}, // вставлять ключ в замок
rus_verbs:встраивать{}, // встраивать черный ход в систему защиты
rus_verbs:встраиваться{}, // встраиваться в систему безопасности
rus_verbs:встревать{}, // встревать в разговор
rus_verbs:встроить{}, // встроить секретный модуль в систему безопасности
rus_verbs:встроиться{}, // встроиться в систему безопасности
rus_verbs:встрять{}, // встрять в разговор
rus_verbs:вступать{}, // вступать в действующую армию
rus_verbs:вступить{}, // вступить в действующую армию
rus_verbs:всунуть{}, // всунуть палец в отверстие
rus_verbs:всунуться{}, // всунуться в форточку
инфинитив:всыпать{вид:соверш}, // всыпать порошок в контейнер
инфинитив:всыпать{вид:несоверш},
глагол:всыпать{вид:соверш},
глагол:всыпать{вид:несоверш},
деепричастие:всыпав{},
деепричастие:всыпая{},
прилагательное:всыпавший{ вид:соверш },
// прилагательное:всыпавший{ вид:несоверш },
прилагательное:всыпанный{},
// прилагательное:всыпающий{},
инфинитив:всыпаться{ вид:несоверш}, // всыпаться в контейнер
// инфинитив:всыпаться{ вид:соверш},
// глагол:всыпаться{ вид:соверш},
глагол:всыпаться{ вид:несоверш},
// деепричастие:всыпавшись{},
деепричастие:всыпаясь{},
// прилагательное:всыпавшийся{ вид:соверш },
// прилагательное:всыпавшийся{ вид:несоверш },
// прилагательное:всыпающийся{},
rus_verbs:вталкивать{}, // вталкивать деталь в ячейку
rus_verbs:вталкиваться{}, // вталкиваться в ячейку
rus_verbs:втаптывать{}, // втаптывать в грязь
rus_verbs:втаптываться{}, // втаптываться в грязь
rus_verbs:втаскивать{}, // втаскивать мешок в комнату
rus_verbs:втаскиваться{}, // втаскиваться в комнату
rus_verbs:втащить{}, // втащить мешок в комнату
rus_verbs:втащиться{}, // втащиться в комнату
rus_verbs:втекать{}, // втекать в бутылку
rus_verbs:втемяшивать{}, // втемяшивать в голову
rus_verbs:втемяшиваться{}, // втемяшиваться в голову
rus_verbs:втемяшить{}, // втемяшить в голову
rus_verbs:втемяшиться{}, // втемяшиться в голову
rus_verbs:втереть{}, // втереть крем в кожу
rus_verbs:втереться{}, // втереться в кожу
rus_verbs:втесаться{}, // втесаться в группу
rus_verbs:втесывать{}, // втесывать в группу
rus_verbs:втесываться{}, // втесываться в группу
rus_verbs:втечь{}, // втечь в бак
rus_verbs:втирать{}, // втирать крем в кожу
rus_verbs:втираться{}, // втираться в кожу
rus_verbs:втискивать{}, // втискивать сумку в вагон
rus_verbs:втискиваться{}, // втискиваться в переполненный вагон
rus_verbs:втиснуть{}, // втиснуть сумку в вагон
rus_verbs:втиснуться{}, // втиснуться в переполненный вагон метро
rus_verbs:втолкать{}, // втолкать коляску в лифт
rus_verbs:втолкаться{}, // втолкаться в вагон метро
rus_verbs:втолкнуть{}, // втолкнуть коляску в лифт
rus_verbs:втолкнуться{}, // втолкнуться в вагон метро
rus_verbs:втолочь{}, // втолочь в смесь
rus_verbs:втоптать{}, // втоптать цветы в землю
rus_verbs:вторгаться{}, // вторгаться в чужую зону
rus_verbs:вторгнуться{}, // вторгнуться в частную жизнь
rus_verbs:втравить{}, // втравить кого-то в неприятности
rus_verbs:втравливать{}, // втравливать кого-то в неприятности
rus_verbs:втрамбовать{}, // втрамбовать камни в землю
rus_verbs:втрамбовывать{}, // втрамбовывать камни в землю
rus_verbs:втрамбовываться{}, // втрамбовываться в землю
rus_verbs:втрескаться{}, // втрескаться в кого-то
rus_verbs:втрескиваться{}, // втрескиваться в кого-либо
rus_verbs:втыкать{}, // втыкать вилку в котлетку
rus_verbs:втыкаться{}, // втыкаться в розетку
rus_verbs:втюриваться{}, // втюриваться в кого-либо
rus_verbs:втюриться{}, // втюриться в кого-либо
rus_verbs:втягивать{}, // втягивать что-то в себя
rus_verbs:втягиваться{}, // втягиваться в себя
rus_verbs:втянуться{}, // втянуться в себя
rus_verbs:вцементировать{}, // вцементировать сваю в фундамент
rus_verbs:вчеканить{}, // вчеканить надпись в лист
rus_verbs:вчитаться{}, // вчитаться внимательнее в текст
rus_verbs:вчитываться{}, // вчитываться внимательнее в текст
rus_verbs:вчувствоваться{}, // вчувствоваться в роль
rus_verbs:вшагивать{}, // вшагивать в новую жизнь
rus_verbs:вшагнуть{}, // вшагнуть в новую жизнь
rus_verbs:вшивать{}, // вшивать заплату в рубашку
rus_verbs:вшиваться{}, // вшиваться в ткань
rus_verbs:вшить{}, // вшить заплату в ткань
rus_verbs:въедаться{}, // въедаться в мякоть
rus_verbs:въезжать{}, // въезжать в гараж
rus_verbs:въехать{}, // въехать в гараж
rus_verbs:выиграть{}, // Коля выиграл в шахматы
rus_verbs:выигрывать{}, // Коля часто выигрывает у меня в шахматы
rus_verbs:выкладывать{}, // выкладывать в общий доступ
rus_verbs:выкладываться{}, // выкладываться в общий доступ
rus_verbs:выкрасить{}, // выкрасить машину в розовый цвет
rus_verbs:выкраситься{}, // выкраситься в дерзкий розовый цвет
rus_verbs:выкрашивать{}, // выкрашивать волосы в красный цвет
rus_verbs:выкрашиваться{}, // выкрашиваться в красный цвет
rus_verbs:вылезать{}, // вылезать в открытое пространство
rus_verbs:вылезти{}, // вылезти в открытое пространство
rus_verbs:выливать{}, // выливать в бутылку
rus_verbs:выливаться{}, // выливаться в ёмкость
rus_verbs:вылить{}, // вылить отходы в канализацию
rus_verbs:вылиться{}, // Топливо вылилось в воду
rus_verbs:выложить{}, // выложить в общий доступ
rus_verbs:выпадать{}, // выпадать в осадок
rus_verbs:выпрыгивать{}, // выпрыгивать в окно
rus_verbs:выпрыгнуть{}, // выпрыгнуть в окно
rus_verbs:выродиться{}, // выродиться в жалкое подобие
rus_verbs:вырождаться{}, // вырождаться в жалкое подобие славных предков
rus_verbs:высеваться{}, // высеваться в землю
rus_verbs:высеять{}, // высеять в землю
rus_verbs:выслать{}, // выслать в страну постоянного пребывания
rus_verbs:высморкаться{}, // высморкаться в платок
rus_verbs:высморкнуться{}, // высморкнуться в платок
rus_verbs:выстреливать{}, // выстреливать в цель
rus_verbs:выстреливаться{}, // выстреливаться в цель
rus_verbs:выстрелить{}, // выстрелить в цель
rus_verbs:вытекать{}, // вытекать в озеро
rus_verbs:вытечь{}, // вытечь в воду
rus_verbs:смотреть{}, // смотреть в будущее
rus_verbs:подняться{}, // подняться в лабораторию
rus_verbs:послать{}, // послать в магазин
rus_verbs:слать{}, // слать в неизвестность
rus_verbs:добавить{}, // добавить в суп
rus_verbs:пройти{}, // пройти в лабораторию
rus_verbs:положить{}, // положить в ящик
rus_verbs:прислать{}, // прислать в полицию
rus_verbs:упасть{}, // упасть в пропасть
инфинитив:писать{ aux stress="пис^ать" }, // писать в газету
инфинитив:писать{ aux stress="п^исать" }, // писать в штанишки
глагол:писать{ aux stress="п^исать" },
глагол:писать{ aux stress="пис^ать" },
деепричастие:писая{},
прилагательное:писавший{ aux stress="п^исавший" }, // писавший в штанишки
прилагательное:писавший{ aux stress="пис^авший" }, // писавший в газету
rus_verbs:собираться{}, // собираться в поход
rus_verbs:звать{}, // звать в ресторан
rus_verbs:направиться{}, // направиться в ресторан
rus_verbs:отправиться{}, // отправиться в ресторан
rus_verbs:поставить{}, // поставить в угол
rus_verbs:целить{}, // целить в мишень
rus_verbs:попасть{}, // попасть в переплет
rus_verbs:ударить{}, // ударить в больное место
rus_verbs:закричать{}, // закричать в микрофон
rus_verbs:опустить{}, // опустить в воду
rus_verbs:принести{}, // принести в дом бездомного щенка
rus_verbs:отдать{}, // отдать в хорошие руки
rus_verbs:ходить{}, // ходить в школу
rus_verbs:уставиться{}, // уставиться в экран
rus_verbs:приходить{}, // приходить в бешенство
rus_verbs:махнуть{}, // махнуть в Италию
rus_verbs:сунуть{}, // сунуть в замочную скважину
rus_verbs:явиться{}, // явиться в расположение части
rus_verbs:уехать{}, // уехать в город
rus_verbs:целовать{}, // целовать в лобик
rus_verbs:повести{}, // повести в бой
rus_verbs:опуститься{}, // опуститься в кресло
rus_verbs:передать{}, // передать в архив
rus_verbs:побежать{}, // побежать в школу
rus_verbs:стечь{}, // стечь в воду
rus_verbs:уходить{}, // уходить добровольцем в армию
rus_verbs:привести{}, // привести в дом
rus_verbs:шагнуть{}, // шагнуть в неизвестность
rus_verbs:собраться{}, // собраться в поход
rus_verbs:заглянуть{}, // заглянуть в основу
rus_verbs:поспешить{}, // поспешить в церковь
rus_verbs:поцеловать{}, // поцеловать в лоб
rus_verbs:перейти{}, // перейти в высшую лигу
rus_verbs:поверить{}, // поверить в искренность
rus_verbs:глянуть{}, // глянуть в оглавление
rus_verbs:зайти{}, // зайти в кафетерий
rus_verbs:подобрать{}, // подобрать в лесу
rus_verbs:проходить{}, // проходить в помещение
rus_verbs:глядеть{}, // глядеть в глаза
rus_verbs:пригласить{}, // пригласить в театр
rus_verbs:позвать{}, // позвать в класс
rus_verbs:усесться{}, // усесться в кресло
rus_verbs:поступить{}, // поступить в институт
rus_verbs:лечь{}, // лечь в постель
rus_verbs:поклониться{}, // поклониться в пояс
rus_verbs:потянуться{}, // потянуться в лес
rus_verbs:колоть{}, // колоть в ягодицу
rus_verbs:присесть{}, // присесть в кресло
rus_verbs:оглядеться{}, // оглядеться в зеркало
rus_verbs:поглядеть{}, // поглядеть в зеркало
rus_verbs:превратиться{}, // превратиться в лягушку
rus_verbs:принимать{}, // принимать во внимание
rus_verbs:звонить{}, // звонить в колокола
rus_verbs:привезти{}, // привезти в гостиницу
rus_verbs:рухнуть{}, // рухнуть в пропасть
rus_verbs:пускать{}, // пускать в дело
rus_verbs:отвести{}, // отвести в больницу
rus_verbs:сойти{}, // сойти в ад
rus_verbs:набрать{}, // набрать в команду
rus_verbs:собрать{}, // собрать в кулак
rus_verbs:двигаться{}, // двигаться в каюту
rus_verbs:падать{}, // падать в область нуля
rus_verbs:полезть{}, // полезть в драку
rus_verbs:направить{}, // направить в стационар
rus_verbs:приводить{}, // приводить в чувство
rus_verbs:толкнуть{}, // толкнуть в бок
rus_verbs:кинуться{}, // кинуться в драку
rus_verbs:ткнуть{}, // ткнуть в глаз
rus_verbs:заключить{}, // заключить в объятия
rus_verbs:подниматься{}, // подниматься в небо
rus_verbs:расти{}, // расти в глубину
rus_verbs:налить{}, // налить в кружку
rus_verbs:швырнуть{}, // швырнуть в бездну
rus_verbs:прыгнуть{}, // прыгнуть в дверь
rus_verbs:промолчать{}, // промолчать в тряпочку
rus_verbs:садиться{}, // садиться в кресло
rus_verbs:лить{}, // лить в кувшин
rus_verbs:дослать{}, // дослать деталь в держатель
rus_verbs:переслать{}, // переслать в обработчик
rus_verbs:удалиться{}, // удалиться в совещательную комнату
rus_verbs:разглядывать{}, // разглядывать в бинокль
rus_verbs:повесить{}, // повесить в шкаф
инфинитив:походить{ вид:соверш }, // походить в институт
глагол:походить{ вид:соверш },
деепричастие:походив{},
// прилагательное:походивший{вид:соверш},
rus_verbs:помчаться{}, // помчаться в класс
rus_verbs:свалиться{}, // свалиться в яму
rus_verbs:сбежать{}, // сбежать в Англию
rus_verbs:стрелять{}, // стрелять в цель
rus_verbs:обращать{}, // обращать в свою веру
rus_verbs:завести{}, // завести в дом
rus_verbs:приобрести{}, // приобрести в рассрочку
rus_verbs:сбросить{}, // сбросить в яму
rus_verbs:устроиться{}, // устроиться в крупную корпорацию
rus_verbs:погрузиться{}, // погрузиться в пучину
rus_verbs:течь{}, // течь в канаву
rus_verbs:произвести{}, // произвести в звание майора
rus_verbs:метать{}, // метать в цель
rus_verbs:пустить{}, // пустить в дело
rus_verbs:полететь{}, // полететь в Европу
rus_verbs:пропустить{}, // пропустить в здание
rus_verbs:рвануть{}, // рвануть в отпуск
rus_verbs:заходить{}, // заходить в каморку
rus_verbs:нырнуть{}, // нырнуть в прорубь
rus_verbs:рвануться{}, // рвануться в атаку
rus_verbs:приподняться{}, // приподняться в воздух
rus_verbs:превращаться{}, // превращаться в крупную величину
rus_verbs:прокричать{}, // прокричать в ухо
rus_verbs:записать{}, // записать в блокнот
rus_verbs:забраться{}, // забраться в шкаф
rus_verbs:приезжать{}, // приезжать в деревню
rus_verbs:продать{}, // продать в рабство
rus_verbs:проникнуть{}, // проникнуть в центр
rus_verbs:устремиться{}, // устремиться в открытое море
rus_verbs:посадить{}, // посадить в кресло
rus_verbs:упереться{}, // упереться в пол
rus_verbs:ринуться{}, // ринуться в буфет
rus_verbs:отдавать{}, // отдавать в кадетское училище
rus_verbs:отложить{}, // отложить в долгий ящик
rus_verbs:убежать{}, // убежать в приют
rus_verbs:оценить{}, // оценить в миллион долларов
rus_verbs:поднимать{}, // поднимать в стратосферу
rus_verbs:отослать{}, // отослать в квалификационную комиссию
rus_verbs:отодвинуть{}, // отодвинуть в дальний угол
rus_verbs:торопиться{}, // торопиться в школу
rus_verbs:попадаться{}, // попадаться в руки
rus_verbs:поразить{}, // поразить в самое сердце
rus_verbs:доставить{}, // доставить в квартиру
rus_verbs:заслать{}, // заслать в тыл
rus_verbs:сослать{}, // сослать в изгнание
rus_verbs:запустить{}, // запустить в космос
rus_verbs:удариться{}, // удариться в запой
rus_verbs:ударяться{}, // ударяться в крайность
rus_verbs:шептать{}, // шептать в лицо
rus_verbs:уронить{}, // уронить в унитаз
rus_verbs:прорычать{}, // прорычать в микрофон
rus_verbs:засунуть{}, // засунуть в глотку
rus_verbs:плыть{}, // плыть в открытое море
rus_verbs:перенести{}, // перенести в духовку
rus_verbs:светить{}, // светить в лицо
rus_verbs:мчаться{}, // мчаться в ремонт
rus_verbs:стукнуть{}, // стукнуть в лоб
rus_verbs:обрушиться{}, // обрушиться в котлован
rus_verbs:поглядывать{}, // поглядывать в экран
rus_verbs:уложить{}, // уложить в кроватку
инфинитив:попадать{ вид:несоверш }, // попадать в черный список
глагол:попадать{ вид:несоверш },
прилагательное:попадающий{ вид:несоверш },
прилагательное:попадавший{ вид:несоверш },
деепричастие:попадая{},
rus_verbs:провалиться{}, // провалиться в яму
rus_verbs:жаловаться{}, // жаловаться в комиссию
rus_verbs:опоздать{}, // опоздать в школу
rus_verbs:посылать{}, // посылать в парикмахерскую
rus_verbs:погнать{}, // погнать в хлев
rus_verbs:поступать{}, // поступать в институт
rus_verbs:усадить{}, // усадить в кресло
rus_verbs:проиграть{}, // проиграть в рулетку
rus_verbs:прилететь{}, // прилететь в страну
rus_verbs:повалиться{}, // повалиться в траву
rus_verbs:огрызнуться{}, // Собака огрызнулась в ответ
rus_verbs:лезть{}, // лезть в чужие дела
rus_verbs:потащить{}, // потащить в суд
rus_verbs:направляться{}, // направляться в порт
rus_verbs:поползти{}, // поползти в другую сторону
rus_verbs:пуститься{}, // пуститься в пляс
rus_verbs:забиться{}, // забиться в нору
rus_verbs:залезть{}, // залезть в конуру
rus_verbs:сдать{}, // сдать в утиль
rus_verbs:тронуться{}, // тронуться в путь
rus_verbs:сыграть{}, // сыграть в шахматы
rus_verbs:перевернуть{}, // перевернуть в более удобную позу
rus_verbs:сжимать{}, // сжимать пальцы в кулак
rus_verbs:подтолкнуть{}, // подтолкнуть в бок
rus_verbs:отнести{}, // отнести животное в лечебницу
rus_verbs:одеться{}, // одеться в зимнюю одежду
rus_verbs:плюнуть{}, // плюнуть в колодец
rus_verbs:передавать{}, // передавать в прокуратуру
rus_verbs:отскочить{}, // отскочить в лоб
rus_verbs:призвать{}, // призвать в армию
rus_verbs:увезти{}, // увезти в деревню
rus_verbs:улечься{}, // улечься в кроватку
rus_verbs:отшатнуться{}, // отшатнуться в сторону
rus_verbs:ложиться{}, // ложиться в постель
rus_verbs:пролететь{}, // пролететь в конец
rus_verbs:класть{}, // класть в сейф
rus_verbs:доставлять{}, // доставлять в кабинет
rus_verbs:приобретать{}, // приобретать в кредит
rus_verbs:сводить{}, // сводить в театр
rus_verbs:унести{}, // унести в могилу
rus_verbs:покатиться{}, // покатиться в яму
rus_verbs:сходить{}, // сходить в магазинчик
rus_verbs:спустить{}, // спустить в канализацию
rus_verbs:проникать{}, // проникать в сердцевину
rus_verbs:метнуть{}, // метнуть в болвана гневный взгляд
rus_verbs:пожаловаться{}, // пожаловаться в администрацию
rus_verbs:стучать{}, // стучать в металлическую дверь
rus_verbs:тащить{}, // тащить в ремонт
rus_verbs:заглядывать{}, // заглядывать в ответы
rus_verbs:плюхнуться{}, // плюхнуться в стол ароматного сена
rus_verbs:увести{}, // увести в следующий кабинет
rus_verbs:успевать{}, // успевать в школу
rus_verbs:пробраться{}, // пробраться в собачью конуру
rus_verbs:подавать{}, // подавать в суд
rus_verbs:прибежать{}, // прибежать в конюшню
rus_verbs:рассмотреть{}, // рассмотреть в микроскоп
rus_verbs:пнуть{}, // пнуть в живот
rus_verbs:завернуть{}, // завернуть в декоративную пленку
rus_verbs:уезжать{}, // уезжать в деревню
rus_verbs:привлекать{}, // привлекать в свои ряды
rus_verbs:перебраться{}, // перебраться в прибрежный город
rus_verbs:долить{}, // долить в коктейль
rus_verbs:палить{}, // палить в нападающих
rus_verbs:отобрать{}, // отобрать в коллекцию
rus_verbs:улететь{}, // улететь в неизвестность
rus_verbs:выглянуть{}, // выглянуть в окно
rus_verbs:выглядывать{}, // выглядывать в окно
rus_verbs:пробираться{}, // грабитель, пробирающийся в дом
инфинитив:написать{ aux stress="напис^ать"}, // читатель, написавший в блог
глагол:написать{ aux stress="напис^ать"},
прилагательное:написавший{ aux stress="напис^авший"},
rus_verbs:свернуть{}, // свернуть в колечко
инфинитив:сползать{ вид:несоверш }, // сползать в овраг
глагол:сползать{ вид:несоверш },
прилагательное:сползающий{ вид:несоверш },
прилагательное:сползавший{ вид:несоверш },
rus_verbs:барабанить{}, // барабанить в дверь
rus_verbs:дописывать{}, // дописывать в конец
rus_verbs:меняться{}, // меняться в лучшую сторону
rus_verbs:измениться{}, // измениться в лучшую сторону
rus_verbs:изменяться{}, // изменяться в лучшую сторону
rus_verbs:вписаться{}, // вписаться в поворот
rus_verbs:вписываться{}, // вписываться в повороты
rus_verbs:переработать{}, // переработать в удобрение
rus_verbs:перерабатывать{}, // перерабатывать в удобрение
rus_verbs:уползать{}, // уползать в тень
rus_verbs:заползать{}, // заползать в нору
rus_verbs:перепрятать{}, // перепрятать в укромное место
rus_verbs:заталкивать{}, // заталкивать в вагон
rus_verbs:преобразовывать{}, // преобразовывать в список
инфинитив:конвертировать{ вид:несоверш }, // конвертировать в список
глагол:конвертировать{ вид:несоверш },
инфинитив:конвертировать{ вид:соверш },
глагол:конвертировать{ вид:соверш },
деепричастие:конвертировав{},
деепричастие:конвертируя{},
rus_verbs:изорвать{}, // Он изорвал газету в клочки.
rus_verbs:выходить{}, // Окна выходят в сад.
rus_verbs:говорить{}, // Он говорил в защиту своего отца.
rus_verbs:вырастать{}, // Он вырастает в большого художника.
rus_verbs:вывести{}, // Он вывел детей в сад.
// инфинитив:всыпать{ вид:соверш }, инфинитив:всыпать{ вид:несоверш },
// глагол:всыпать{ вид:соверш }, глагол:всыпать{ вид:несоверш }, // Он всыпал в воду две ложки соли.
// прилагательное:раненый{}, // Он был ранен в левую руку.
// прилагательное:одетый{}, // Он был одет в толстое осеннее пальто.
rus_verbs:бухнуться{}, // Он бухнулся в воду.
rus_verbs:склонять{}, // склонять защиту в свою пользу
rus_verbs:впиться{}, // Пиявка впилась в тело.
rus_verbs:сходиться{}, // Интеллигенты начала века часто сходились в разные союзы
rus_verbs:сохранять{}, // сохранить данные в файл
rus_verbs:собирать{}, // собирать игрушки в ящик
rus_verbs:упаковывать{}, // упаковывать вещи в чемодан
rus_verbs:обращаться{}, // Обращайтесь ко мне в любое время
rus_verbs:стрельнуть{}, // стрельни в толпу!
rus_verbs:пулять{}, // пуляй в толпу
rus_verbs:пульнуть{}, // пульни в толпу
rus_verbs:становиться{}, // Становитесь в очередь.
rus_verbs:вписать{}, // Юля вписала свое имя в список.
rus_verbs:вписывать{}, // Мы вписывали свои имена в список
прилагательное:видный{}, // Планета Марс видна в обычный бинокль
rus_verbs:пойти{}, // Девочка рано пошла в школу
rus_verbs:отойти{}, // Эти обычаи отошли в историю.
rus_verbs:бить{}, // Холодный ветер бил ему в лицо.
rus_verbs:входить{}, // Это входит в его обязанности.
rus_verbs:принять{}, // меня приняли в пионеры
rus_verbs:уйти{}, // Правительство РФ ушло в отставку
rus_verbs:допустить{}, // Япония была допущена в Организацию Объединённых Наций в 1956 году.
rus_verbs:посвятить{}, // Я посвятил друга в свою тайну.
инфинитив:экспортировать{ вид:несоверш }, глагол:экспортировать{ вид:несоверш }, // экспортировать нефть в страны Востока
rus_verbs:взглянуть{}, // Я не смел взглянуть ему в глаза.
rus_verbs:идти{}, // Я иду гулять в парк.
rus_verbs:вскочить{}, // Я вскочил в трамвай и помчался в институт.
rus_verbs:получить{}, // Эту мебель мы получили в наследство от родителей.
rus_verbs:везти{}, // Учитель везёт детей в лагерь.
rus_verbs:качать{}, // Судно качает во все стороны.
rus_verbs:заезжать{}, // Сегодня вечером я заезжал в магазин за книгами.
rus_verbs:связать{}, // Свяжите свои вещи в узелок.
rus_verbs:пронести{}, // Пронесите стол в дверь.
rus_verbs:вынести{}, // Надо вынести примечания в конец.
rus_verbs:устроить{}, // Она устроила сына в школу.
rus_verbs:угодить{}, // Она угодила головой в дверь.
rus_verbs:отвернуться{}, // Она резко отвернулась в сторону.
rus_verbs:рассматривать{}, // Она рассматривала сцену в бинокль.
rus_verbs:обратить{}, // Война обратила город в развалины.
rus_verbs:сойтись{}, // Мы сошлись в школьные годы.
rus_verbs:приехать{}, // Мы приехали в положенный час.
rus_verbs:встать{}, // Дети встали в круг.
rus_verbs:впасть{}, // Из-за болезни он впал в нужду.
rus_verbs:придти{}, // придти в упадок
rus_verbs:заявить{}, // Надо заявить в милицию о краже.
rus_verbs:заявлять{}, // заявлять в полицию
rus_verbs:ехать{}, // Мы будем ехать в Орёл
rus_verbs:окрашиваться{}, // окрашиваться в красный цвет
rus_verbs:решить{}, // Дело решено в пользу истца.
rus_verbs:сесть{}, // Она села в кресло
rus_verbs:посмотреть{}, // Она посмотрела на себя в зеркало.
rus_verbs:влезать{}, // он влезает в мою квартирку
rus_verbs:попасться{}, // в мою ловушку попалась мышь
rus_verbs:лететь{}, // Мы летим в Орёл
ГЛ_ИНФ(брать), // он берет в свою правую руку очень тяжелый шершавый камень
ГЛ_ИНФ(взять), // Коля взял в руку камень
ГЛ_ИНФ(поехать), // поехать в круиз
ГЛ_ИНФ(подать), // подать в отставку
инфинитив:засыпать{ вид:соверш }, глагол:засыпать{ вид:соверш }, // засыпать песок в ящик
инфинитив:засыпать{ вид:несоверш переходность:переходный }, глагол:засыпать{ вид:несоверш переходность:переходный }, // засыпать песок в ящик
ГЛ_ИНФ(впадать), прилагательное:впадающий{}, прилагательное:впадавший{}, деепричастие:впадая{}, // впадать в море
ГЛ_ИНФ(постучать) // постучать в дверь
}
// Чтобы разрешить связывание в паттернах типа: уйти в BEA Systems
fact гл_предл
{
if context { Гл_В_Вин предлог:в{} @regex("[a-z]+[0-9]*") }
then return true
}
fact гл_предл
{
if context { Гл_В_Вин предлог:в{} *:*{ падеж:вин } }
then return true
}
fact гл_предл
{
if context { глагол:подвывать{} предлог:в{} существительное:такт{ падеж:вин } }
then return true
}
#endregion Винительный
// Все остальные варианты по умолчанию запрещаем.
fact гл_предл
{
if context { * предлог:в{} *:*{ падеж:предл } }
then return false,-3
}
fact гл_предл
{
if context { * предлог:в{} *:*{ падеж:мест } }
then return false,-3
}
fact гл_предл
{
if context { * предлог:в{} *:*{ падеж:вин } }
then return false,-4
}
fact гл_предл
{
if context { * предлог:в{} * }
then return false,-5
}
#endregion Предлог_В
#region Предлог_НА
// ------------------- С ПРЕДЛОГОМ 'НА' ---------------------------
#region ПРЕДЛОЖНЫЙ
// НА+предложный падеж:
// ЛЕЖАТЬ НА СТОЛЕ
#region VerbList
wordentry_set Гл_НА_Предл=
{
rus_verbs:заслушать{}, // Вопрос заслушали на сессии облсовета
rus_verbs:ПРОСТУПАТЬ{}, // На лбу, носу и щеке проступало черное пятно кровоподтека. (ПРОСТУПАТЬ/ПРОСТУПИТЬ)
rus_verbs:ПРОСТУПИТЬ{}, //
rus_verbs:ВИДНЕТЬСЯ{}, // На другой стороне Океана виднелась полоска суши, окружавшая нижний ярус планеты. (ВИДНЕТЬСЯ)
rus_verbs:ЗАВИСАТЬ{}, // Машина умела зависать в воздухе на любой высоте (ЗАВИСАТЬ)
rus_verbs:ЗАМЕРЕТЬ{}, // Скользнув по траве, он замер на боку (ЗАМЕРЕТЬ, локатив)
rus_verbs:ЗАМИРАТЬ{}, //
rus_verbs:ЗАКРЕПИТЬ{}, // Он вручил ей лишний кинжал, который она воткнула в рубаху и закрепила на подоле. (ЗАКРЕПИТЬ)
rus_verbs:УПОЛЗТИ{}, // Зверь завизжал и попытался уползти на двух невредимых передних ногах. (УПОЛЗТИ/УПОЛЗАТЬ)
rus_verbs:УПОЛЗАТЬ{}, //
rus_verbs:БОЛТАТЬСЯ{}, // Тело его будет болтаться на пространственных ветрах, пока не сгниет веревка. (БОЛТАТЬСЯ)
rus_verbs:РАЗВЕРНУТЬ{}, // Филиппины разрешат США развернуть военные базы на своей территории (РАЗВЕРНУТЬ)
rus_verbs:ПОЛУЧИТЬ{}, // Я пытался узнать секреты и получить советы на официальном русскоязычном форуме (ПОЛУЧИТЬ)
rus_verbs:ЗАСИЯТЬ{}, // Он активировал управление, и на экране снова засияло изображение полумесяца. (ЗАСИЯТЬ)
rus_verbs:ВЗОРВАТЬСЯ{}, // Смертник взорвался на предвыборном митинге в Пакистане (ВЗОРВАТЬСЯ)
rus_verbs:искриться{},
rus_verbs:ОДЕРЖИВАТЬ{}, // На выборах в иранский парламент победу одерживают противники действующего президента (ОДЕРЖИВАТЬ)
rus_verbs:ПРЕСЕЧЬ{}, // На Украине пресекли дерзкий побег заключенных на вертолете (ПРЕСЕЧЬ)
rus_verbs:УЛЕТЕТЬ{}, // Голый норвежец улетел на лыжах с трамплина на 60 метров (УЛЕТЕТЬ)
rus_verbs:ПРОХОДИТЬ{}, // укрывающийся в лесу американский подросток проходил инициацию на охоте, выпив кружку крови первого убитого им оленя (ПРОХОДИТЬ)
rus_verbs:СУЩЕСТВОВАТЬ{}, // На Марсе существовали условия для жизни (СУЩЕСТВОВАТЬ)
rus_verbs:УКАЗАТЬ{}, // Победу в Лиге чемпионов укажут на часах (УКАЗАТЬ)
rus_verbs:отвести{}, // отвести душу на людях
rus_verbs:сходиться{}, // Оба профессора сходились на том, что в черепной коробке динозавра
rus_verbs:сойтись{},
rus_verbs:ОБНАРУЖИТЬ{}, // Доказательство наличия подповерхностного океана на Европе обнаружено на её поверхности (ОБНАРУЖИТЬ)
rus_verbs:НАБЛЮДАТЬСЯ{}, // Редкий зодиакальный свет вскоре будет наблюдаться на ночном небе (НАБЛЮДАТЬСЯ)
rus_verbs:ДОСТИГНУТЬ{}, // На всех аварийных реакторах достигнуто состояние так называемой холодной остановки (ДОСТИГНУТЬ/ДОСТИЧЬ)
глагол:ДОСТИЧЬ{},
инфинитив:ДОСТИЧЬ{},
rus_verbs:завершить{}, // Российские биатлонисты завершили чемпионат мира на мажорной ноте
rus_verbs:РАСКЛАДЫВАТЬ{},
rus_verbs:ФОКУСИРОВАТЬСЯ{}, // Инвесторы предпочитают фокусироваться на среднесрочных ожиданиях (ФОКУСИРОВАТЬСЯ)
rus_verbs:ВОСПРИНИМАТЬ{}, // как несерьезно воспринимали его на выборах мэра (ВОСПРИНИМАТЬ)
rus_verbs:БУШЕВАТЬ{}, // на территории Тверской области бушевала гроза , в результате которой произошло отключение электроснабжения в ряде муниципальных образований региона (БУШЕВАТЬ)
rus_verbs:УЧАСТИТЬСЯ{}, // В последние месяцы в зоне ответственности бундесвера на севере Афганистана участились случаи обстрелов полевых лагерей немецких миротворцев (УЧАСТИТЬСЯ)
rus_verbs:ВЫИГРАТЬ{}, // Почему женская сборная России не может выиграть медаль на чемпионате мира (ВЫИГРАТЬ)
rus_verbs:ПРОПАСТЬ{}, // Пропавшим на прогулке актером заинтересовались следователи (ПРОПАСТЬ)
rus_verbs:УБИТЬ{}, // Силовики убили двух боевиков на административной границе Ингушетии и Чечни (УБИТЬ)
rus_verbs:подпрыгнуть{}, // кобель нелепо подпрыгнул на трех ногах , а его хозяин отправил струю пива мимо рта
rus_verbs:подпрыгивать{},
rus_verbs:высветиться{}, // на компьютере высветится твоя подпись
rus_verbs:фигурировать{}, // его портрет фигурирует на страницах печати и телеэкранах
rus_verbs:действовать{}, // выявленный контрабандный канал действовал на постоянной основе
rus_verbs:СОХРАНИТЬСЯ{}, // На рынке международных сделок IPO сохранится высокая активность (СОХРАНИТЬСЯ НА)
rus_verbs:ПРОЙТИ{}, // Необычный конкурс прошёл на севере Швеции (ПРОЙТИ НА предл)
rus_verbs:НАЧАТЬСЯ{}, // На северо-востоке США началась сильная снежная буря. (НАЧАТЬСЯ НА предл)
rus_verbs:ВОЗНИКНУТЬ{}, // Конфликт возник на почве совместной коммерческой деятельности по выращиванию овощей и зелени (ВОЗНИКНУТЬ НА)
rus_verbs:СВЕТИТЬСЯ{}, // она по-прежнему светится на лицах людей (СВЕТИТЬСЯ НА предл)
rus_verbs:ОРГАНИЗОВАТЬ{}, // Власти Москвы намерены организовать масленичные гуляния на 100 площадках (ОРГАНИЗОВАТЬ НА предл)
rus_verbs:ИМЕТЬ{}, // Имея власть на низовом уровне, оказывать самое непосредственное и определяющее влияние на верховную власть (ИМЕТЬ НА предл)
rus_verbs:ОПРОБОВАТЬ{}, // Опробовать и отточить этот инструмент на местных и региональных выборах (ОПРОБОВАТЬ, ОТТОЧИТЬ НА предл)
rus_verbs:ОТТОЧИТЬ{},
rus_verbs:ДОЛОЖИТЬ{}, // Участникам совещания предложено подготовить по этому вопросу свои предложения и доложить на повторной встрече (ДОЛОЖИТЬ НА предл)
rus_verbs:ОБРАЗОВЫВАТЬСЯ{}, // Солевые и пылевые бури , образующиеся на поверхности обнаженной площади моря , уничтожают урожаи и растительность (ОБРАЗОВЫВАТЬСЯ НА)
rus_verbs:СОБРАТЬ{}, // использует собранные на местном рынке депозиты (СОБРАТЬ НА предл)
инфинитив:НАХОДИТЬСЯ{ вид:несоверш}, // находившихся на борту самолета (НАХОДИТЬСЯ НА предл)
глагол:НАХОДИТЬСЯ{ вид:несоверш },
прилагательное:находившийся{ вид:несоверш },
прилагательное:находящийся{ вид:несоверш },
деепричастие:находясь{},
rus_verbs:ГОТОВИТЬ{}, // пищу готовят сами на примусах (ГОТОВИТЬ НА предл)
rus_verbs:РАЗДАТЬСЯ{}, // Они сообщили о сильном хлопке , который раздался на территории нефтебазы (РАЗДАТЬСЯ НА)
rus_verbs:ПОДСКАЛЬЗЫВАТЬСЯ{}, // подскальзываться на той же апельсиновой корке (ПОДСКАЛЬЗЫВАТЬСЯ НА)
rus_verbs:СКРЫТЬСЯ{}, // Германия: латвиец ограбил магазин и попытался скрыться на такси (СКРЫТЬСЯ НА предл)
rus_verbs:ВЫРАСТИТЬ{}, // Пациенту вырастили новый нос на руке (ВЫРАСТИТЬ НА)
rus_verbs:ПРОДЕМОНСТРИРОВАТЬ{}, // Они хотят подчеркнуть эмоциональную тонкость оппозиционера и на этом фоне продемонстрировать бездушность российской власти (ПРОДЕМОНСТРИРОВАТЬ НА предл)
rus_verbs:ОСУЩЕСТВЛЯТЬСЯ{}, // первичный анализ смеси запахов может осуществляться уже на уровне рецепторных нейронов благодаря механизму латерального торможения (ОСУЩЕСТВЛЯТЬСЯ НА)
rus_verbs:ВЫДЕЛЯТЬСЯ{}, // Ягоды брусники, резко выделяющиеся своим красным цветом на фоне зелёной листвы, поедаются животными и птицами (ВЫДЕЛЯТЬСЯ НА)
rus_verbs:РАСКРЫТЬ{}, // На Украине раскрыто крупное мошенничество в сфере туризма (РАСКРЫТЬ НА)
rus_verbs:ОБЖАРИВАТЬСЯ{}, // Омлет обжаривается на сливочном масле с одной стороны, пока он почти полностью не загустеет (ОБЖАРИВАТЬСЯ НА)
rus_verbs:ПРИГОТОВЛЯТЬ{}, // Яичница — блюдо европейской кухни, приготовляемое на сковороде из разбитых яиц (ПРИГОТОВЛЯТЬ НА)
rus_verbs:РАССАДИТЬ{}, // Женька рассадил игрушки на скамеечке (РАССАДИТЬ НА)
rus_verbs:ОБОЖДАТЬ{}, // обожди Анжелу на остановке троллейбуса (ОБОЖДАТЬ НА)
rus_verbs:УЧИТЬСЯ{}, // Марина учится на факультете журналистики (УЧИТЬСЯ НА предл)
rus_verbs:раскладываться{}, // Созревшие семенные экземпляры раскладывают на солнце или в теплом месте, где они делаются мягкими (РАСКЛАДЫВАТЬСЯ В, НА)
rus_verbs:ПОСЛУШАТЬ{}, // Послушайте друзей и врагов на расстоянии! (ПОСЛУШАТЬ НА)
rus_verbs:ВЕСТИСЬ{}, // На стороне противника всю ночь велась перегруппировка сил. (ВЕСТИСЬ НА)
rus_verbs:ПОИНТЕРЕСОВАТЬСЯ{}, // корреспондент поинтересовался у людей на улице (ПОИНТЕРЕСОВАТЬСЯ НА)
rus_verbs:ОТКРЫВАТЬСЯ{}, // Российские биржи открываются на негативном фоне (ОТКРЫВАТЬСЯ НА)
rus_verbs:СХОДИТЬ{}, // Вы сходите на следующей остановке? (СХОДИТЬ НА)
rus_verbs:ПОГИБНУТЬ{}, // Её отец погиб на войне. (ПОГИБНУТЬ НА)
rus_verbs:ВЫЙТИ{}, // Книга выйдет на будущей неделе. (ВЫЙТИ НА предл)
rus_verbs:НЕСТИСЬ{}, // Корабль несётся на всех парусах. (НЕСТИСЬ НА предл)
rus_verbs:вкалывать{}, // Папа вкалывает на работе, чтобы прокормить семью (вкалывать на)
rus_verbs:доказать{}, // разработчики доказали на практике применимость данного подхода к обсчету сцен (доказать на, применимость к)
rus_verbs:хулиганить{}, // дозволять кому-то хулиганить на кладбище (хулиганить на)
глагол:вычитать{вид:соверш}, инфинитив:вычитать{вид:соверш}, // вычитать на сайте (вычитать на сайте)
деепричастие:вычитав{},
rus_verbs:аккомпанировать{}, // он аккомпанировал певцу на губной гармошке (аккомпанировать на)
rus_verbs:набрать{}, // статья с заголовком, набранным на компьютере
rus_verbs:сделать{}, // книга с иллюстрацией, сделанной на компьютере
rus_verbs:развалиться{}, // Антонио развалился на диване
rus_verbs:улечься{}, // Антонио улегся на полу
rus_verbs:зарубить{}, // Заруби себе на носу.
rus_verbs:ценить{}, // Его ценят на заводе.
rus_verbs:вернуться{}, // Отец вернулся на закате.
rus_verbs:шить{}, // Вы умеете шить на машинке?
rus_verbs:бить{}, // Скот бьют на бойне.
rus_verbs:выехать{}, // Мы выехали на рассвете.
rus_verbs:валяться{}, // На полу валяется бумага.
rus_verbs:разложить{}, // она разложила полотенце на песке
rus_verbs:заниматься{}, // я занимаюсь на тренажере
rus_verbs:позаниматься{},
rus_verbs:порхать{}, // порхать на лугу
rus_verbs:пресекать{}, // пресекать на корню
rus_verbs:изъясняться{}, // изъясняться на непонятном языке
rus_verbs:развесить{}, // развесить на столбах
rus_verbs:обрасти{}, // обрасти на южной части
rus_verbs:откладываться{}, // откладываться на стенках артерий
rus_verbs:уносить{}, // уносить на носилках
rus_verbs:проплыть{}, // проплыть на плоту
rus_verbs:подъезжать{}, // подъезжать на повозках
rus_verbs:пульсировать{}, // пульсировать на лбу
rus_verbs:рассесться{}, // птицы расселись на ветках
rus_verbs:застопориться{}, // застопориться на первом пункте
rus_verbs:изловить{}, // изловить на окраинах
rus_verbs:покататься{}, // покататься на машинках
rus_verbs:залопотать{}, // залопотать на неизвестном языке
rus_verbs:растягивать{}, // растягивать на станке
rus_verbs:поделывать{}, // поделывать на пляже
rus_verbs:подстеречь{}, // подстеречь на площадке
rus_verbs:проектировать{}, // проектировать на компьютере
rus_verbs:притулиться{}, // притулиться на кушетке
rus_verbs:дозволять{}, // дозволять кому-то хулиганить на кладбище
rus_verbs:пострелять{}, // пострелять на испытательном полигоне
rus_verbs:засиживаться{}, // засиживаться на работе
rus_verbs:нежиться{}, // нежиться на солнышке
rus_verbs:притомиться{}, // притомиться на рабочем месте
rus_verbs:поселяться{}, // поселяться на чердаке
rus_verbs:потягиваться{}, // потягиваться на земле
rus_verbs:отлеживаться{}, // отлеживаться на койке
rus_verbs:протаранить{}, // протаранить на танке
rus_verbs:гарцевать{}, // гарцевать на коне
rus_verbs:облупиться{}, // облупиться на носу
rus_verbs:оговорить{}, // оговорить на собеседовании
rus_verbs:зарегистрироваться{}, // зарегистрироваться на сайте
rus_verbs:отпечатать{}, // отпечатать на картоне
rus_verbs:сэкономить{}, // сэкономить на мелочах
rus_verbs:покатать{}, // покатать на пони
rus_verbs:колесить{}, // колесить на старой машине
rus_verbs:понастроить{}, // понастроить на участках
rus_verbs:поджарить{}, // поджарить на костре
rus_verbs:узнаваться{}, // узнаваться на фотографии
rus_verbs:отощать{}, // отощать на казенных харчах
rus_verbs:редеть{}, // редеть на макушке
rus_verbs:оглашать{}, // оглашать на общем собрании
rus_verbs:лопотать{}, // лопотать на иврите
rus_verbs:пригреть{}, // пригреть на груди
rus_verbs:консультироваться{}, // консультироваться на форуме
rus_verbs:приноситься{}, // приноситься на одежде
rus_verbs:сушиться{}, // сушиться на балконе
rus_verbs:наследить{}, // наследить на полу
rus_verbs:нагреться{}, // нагреться на солнце
rus_verbs:рыбачить{}, // рыбачить на озере
rus_verbs:прокатить{}, // прокатить на выборах
rus_verbs:запинаться{}, // запинаться на ровном месте
rus_verbs:отрубиться{}, // отрубиться на мягкой подушке
rus_verbs:заморозить{}, // заморозить на улице
rus_verbs:промерзнуть{}, // промерзнуть на открытом воздухе
rus_verbs:просохнуть{}, // просохнуть на батарее
rus_verbs:развозить{}, // развозить на велосипеде
rus_verbs:прикорнуть{}, // прикорнуть на диванчике
rus_verbs:отпечататься{}, // отпечататься на коже
rus_verbs:выявлять{}, // выявлять на таможне
rus_verbs:расставлять{}, // расставлять на башнях
rus_verbs:прокрутить{}, // прокрутить на пальце
rus_verbs:умываться{}, // умываться на улице
rus_verbs:пересказывать{}, // пересказывать на страницах романа
rus_verbs:удалять{}, // удалять на пуховике
rus_verbs:хозяйничать{}, // хозяйничать на складе
rus_verbs:оперировать{}, // оперировать на поле боя
rus_verbs:поносить{}, // поносить на голове
rus_verbs:замурлыкать{}, // замурлыкать на коленях
rus_verbs:передвигать{}, // передвигать на тележке
rus_verbs:прочертить{}, // прочертить на земле
rus_verbs:колдовать{}, // колдовать на кухне
rus_verbs:отвозить{}, // отвозить на казенном транспорте
rus_verbs:трахать{}, // трахать на природе
rus_verbs:мастерить{}, // мастерить на кухне
rus_verbs:ремонтировать{}, // ремонтировать на коленке
rus_verbs:развезти{}, // развезти на велосипеде
rus_verbs:робеть{}, // робеть на сцене
инфинитив:реализовать{ вид:несоверш }, инфинитив:реализовать{ вид:соверш }, // реализовать на сайте
глагол:реализовать{ вид:несоверш }, глагол:реализовать{ вид:соверш },
деепричастие:реализовав{}, деепричастие:реализуя{},
rus_verbs:покаяться{}, // покаяться на смертном одре
rus_verbs:специализироваться{}, // специализироваться на тестировании
rus_verbs:попрыгать{}, // попрыгать на батуте
rus_verbs:переписывать{}, // переписывать на столе
rus_verbs:расписывать{}, // расписывать на доске
rus_verbs:зажимать{}, // зажимать на запястье
rus_verbs:практиковаться{}, // практиковаться на мышах
rus_verbs:уединиться{}, // уединиться на чердаке
rus_verbs:подохнуть{}, // подохнуть на чужбине
rus_verbs:приподниматься{}, // приподниматься на руках
rus_verbs:уродиться{}, // уродиться на полях
rus_verbs:продолжиться{}, // продолжиться на улице
rus_verbs:посапывать{}, // посапывать на диване
rus_verbs:ободрать{}, // ободрать на спине
rus_verbs:скрючиться{}, // скрючиться на песке
rus_verbs:тормознуть{}, // тормознуть на перекрестке
rus_verbs:лютовать{}, // лютовать на хуторе
rus_verbs:зарегистрировать{}, // зарегистрировать на сайте
rus_verbs:переждать{}, // переждать на вершине холма
rus_verbs:доминировать{}, // доминировать на территории
rus_verbs:публиковать{}, // публиковать на сайте
rus_verbs:морщить{}, // морщить на лбу
rus_verbs:сконцентрироваться{}, // сконцентрироваться на главном
rus_verbs:подрабатывать{}, // подрабатывать на рынке
rus_verbs:репетировать{}, // репетировать на заднем дворе
rus_verbs:подвернуть{}, // подвернуть на брусчатке
rus_verbs:зашелестеть{}, // зашелестеть на ветру
rus_verbs:расчесывать{}, // расчесывать на спине
rus_verbs:одевать{}, // одевать на рынке
rus_verbs:испечь{}, // испечь на углях
rus_verbs:сбрить{}, // сбрить на затылке
rus_verbs:согреться{}, // согреться на печке
rus_verbs:замаячить{}, // замаячить на горизонте
rus_verbs:пересчитывать{}, // пересчитывать на пальцах
rus_verbs:галдеть{}, // галдеть на крыльце
rus_verbs:переплыть{}, // переплыть на плоту
rus_verbs:передохнуть{}, // передохнуть на скамейке
rus_verbs:прижиться{}, // прижиться на ферме
rus_verbs:переправляться{}, // переправляться на плотах
rus_verbs:накупить{}, // накупить на блошином рынке
rus_verbs:проторчать{}, // проторчать на виду
rus_verbs:мокнуть{}, // мокнуть на улице
rus_verbs:застукать{}, // застукать на камбузе
rus_verbs:завязывать{}, // завязывать на ботинках
rus_verbs:повисать{}, // повисать на ветке
rus_verbs:подвизаться{}, // подвизаться на государственной службе
rus_verbs:кормиться{}, // кормиться на болоте
rus_verbs:покурить{}, // покурить на улице
rus_verbs:зимовать{}, // зимовать на болотах
rus_verbs:застегивать{}, // застегивать на гимнастерке
rus_verbs:поигрывать{}, // поигрывать на гитаре
rus_verbs:погореть{}, // погореть на махинациях с землей
rus_verbs:кувыркаться{}, // кувыркаться на батуте
rus_verbs:похрапывать{}, // похрапывать на диване
rus_verbs:пригревать{}, // пригревать на груди
rus_verbs:завязнуть{}, // завязнуть на болоте
rus_verbs:шастать{}, // шастать на втором этаже
rus_verbs:заночевать{}, // заночевать на сеновале
rus_verbs:отсиживаться{}, // отсиживаться на чердаке
rus_verbs:мчать{}, // мчать на байке
rus_verbs:сгнить{}, // сгнить на урановых рудниках
rus_verbs:тренировать{}, // тренировать на манекенах
rus_verbs:повеселиться{}, // повеселиться на празднике
rus_verbs:измучиться{}, // измучиться на болоте
rus_verbs:увянуть{}, // увянуть на подоконнике
rus_verbs:раскрутить{}, // раскрутить на оси
rus_verbs:выцвести{}, // выцвести на солнечном свету
rus_verbs:изготовлять{}, // изготовлять на коленке
rus_verbs:гнездиться{}, // гнездиться на вершине дерева
rus_verbs:разогнаться{}, // разогнаться на мотоцикле
rus_verbs:излагаться{}, // излагаться на страницах доклада
rus_verbs:сконцентрировать{}, // сконцентрировать на левом фланге
rus_verbs:расчесать{}, // расчесать на макушке
rus_verbs:плавиться{}, // плавиться на солнце
rus_verbs:редактировать{}, // редактировать на ноутбуке
rus_verbs:подскакивать{}, // подскакивать на месте
rus_verbs:покупаться{}, // покупаться на рынке
rus_verbs:промышлять{}, // промышлять на мелководье
rus_verbs:приобретаться{}, // приобретаться на распродажах
rus_verbs:наигрывать{}, // наигрывать на банджо
rus_verbs:маневрировать{}, // маневрировать на флангах
rus_verbs:запечатлеться{}, // запечатлеться на записях камер
rus_verbs:укрывать{}, // укрывать на чердаке
rus_verbs:подорваться{}, // подорваться на фугасе
rus_verbs:закрепиться{}, // закрепиться на занятых позициях
rus_verbs:громыхать{}, // громыхать на кухне
инфинитив:подвигаться{ вид:соверш }, глагол:подвигаться{ вид:соверш }, // подвигаться на полу
деепричастие:подвигавшись{},
rus_verbs:добываться{}, // добываться на территории Анголы
rus_verbs:приплясывать{}, // приплясывать на сцене
rus_verbs:доживать{}, // доживать на больничной койке
rus_verbs:отпраздновать{}, // отпраздновать на работе
rus_verbs:сгубить{}, // сгубить на корню
rus_verbs:схоронить{}, // схоронить на кладбище
rus_verbs:тускнеть{}, // тускнеть на солнце
rus_verbs:скопить{}, // скопить на счету
rus_verbs:помыть{}, // помыть на своем этаже
rus_verbs:пороть{}, // пороть на конюшне
rus_verbs:наличествовать{}, // наличествовать на складе
rus_verbs:нащупывать{}, // нащупывать на полке
rus_verbs:змеиться{}, // змеиться на дне
rus_verbs:пожелтеть{}, // пожелтеть на солнце
rus_verbs:заостриться{}, // заостриться на конце
rus_verbs:свезти{}, // свезти на поле
rus_verbs:прочувствовать{}, // прочувствовать на своей шкуре
rus_verbs:подкрутить{}, // подкрутить на приборной панели
rus_verbs:рубиться{}, // рубиться на мечах
rus_verbs:сиживать{}, // сиживать на крыльце
rus_verbs:тараторить{}, // тараторить на иностранном языке
rus_verbs:теплеть{}, // теплеть на сердце
rus_verbs:покачаться{}, // покачаться на ветке
rus_verbs:сосредоточиваться{}, // сосредоточиваться на главной задаче
rus_verbs:развязывать{}, // развязывать на ботинках
rus_verbs:подвозить{}, // подвозить на мотороллере
rus_verbs:вышивать{}, // вышивать на рубашке
rus_verbs:скупать{}, // скупать на открытом рынке
rus_verbs:оформлять{}, // оформлять на встрече
rus_verbs:распускаться{}, // распускаться на клумбах
rus_verbs:прогореть{}, // прогореть на спекуляциях
rus_verbs:приползти{}, // приползти на коленях
rus_verbs:загореть{}, // загореть на пляже
rus_verbs:остудить{}, // остудить на балконе
rus_verbs:нарвать{}, // нарвать на поляне
rus_verbs:издохнуть{}, // издохнуть на болоте
rus_verbs:разгружать{}, // разгружать на дороге
rus_verbs:произрастать{}, // произрастать на болотах
rus_verbs:разуться{}, // разуться на коврике
rus_verbs:сооружать{}, // сооружать на площади
rus_verbs:зачитывать{}, // зачитывать на митинге
rus_verbs:уместиться{}, // уместиться на ладони
rus_verbs:закупить{}, // закупить на рынке
rus_verbs:горланить{}, // горланить на улице
rus_verbs:экономить{}, // экономить на спичках
rus_verbs:исправлять{}, // исправлять на доске
rus_verbs:расслабляться{}, // расслабляться на лежаке
rus_verbs:скапливаться{}, // скапливаться на крыше
rus_verbs:сплетничать{}, // сплетничать на скамеечке
rus_verbs:отъезжать{}, // отъезжать на лимузине
rus_verbs:отчитывать{}, // отчитывать на собрании
rus_verbs:сфокусировать{}, // сфокусировать на удаленной точке
rus_verbs:потчевать{}, // потчевать на лаврах
rus_verbs:окопаться{}, // окопаться на окраине
rus_verbs:загорать{}, // загорать на пляже
rus_verbs:обгореть{}, // обгореть на солнце
rus_verbs:распознавать{}, // распознавать на фотографии
rus_verbs:заплетаться{}, // заплетаться на макушке
rus_verbs:перегреться{}, // перегреться на жаре
rus_verbs:подметать{}, // подметать на крыльце
rus_verbs:нарисоваться{}, // нарисоваться на горизонте
rus_verbs:проскакивать{}, // проскакивать на экране
rus_verbs:попивать{}, // попивать на балконе чай
rus_verbs:отплывать{}, // отплывать на лодке
rus_verbs:чирикать{}, // чирикать на ветках
rus_verbs:скупить{}, // скупить на оптовых базах
rus_verbs:наколоть{}, // наколоть на коже картинку
rus_verbs:созревать{}, // созревать на ветке
rus_verbs:проколоться{}, // проколоться на мелочи
rus_verbs:крутнуться{}, // крутнуться на заднем колесе
rus_verbs:переночевать{}, // переночевать на постоялом дворе
rus_verbs:концентрироваться{}, // концентрироваться на фильтре
rus_verbs:одичать{}, // одичать на хуторе
rus_verbs:спасаться{}, // спасаются на лодке
rus_verbs:доказываться{}, // доказываться на страницах книги
rus_verbs:познаваться{}, // познаваться на ринге
rus_verbs:замыкаться{}, // замыкаться на металлическом предмете
rus_verbs:заприметить{}, // заприметить на пригорке
rus_verbs:продержать{}, // продержать на морозе
rus_verbs:форсировать{}, // форсировать на плотах
rus_verbs:сохнуть{}, // сохнуть на солнце
rus_verbs:выявить{}, // выявить на поверхности
rus_verbs:заседать{}, // заседать на кафедре
rus_verbs:расплачиваться{}, // расплачиваться на выходе
rus_verbs:светлеть{}, // светлеть на горизонте
rus_verbs:залепетать{}, // залепетать на незнакомом языке
rus_verbs:подсчитывать{}, // подсчитывать на пальцах
rus_verbs:зарыть{}, // зарыть на пустыре
rus_verbs:сформироваться{}, // сформироваться на месте
rus_verbs:развертываться{}, // развертываться на площадке
rus_verbs:набивать{}, // набивать на манекенах
rus_verbs:замерзать{}, // замерзать на ветру
rus_verbs:схватывать{}, // схватывать на лету
rus_verbs:перевестись{}, // перевестись на Руси
rus_verbs:смешивать{}, // смешивать на блюдце
rus_verbs:прождать{}, // прождать на входе
rus_verbs:мерзнуть{}, // мерзнуть на ветру
rus_verbs:растирать{}, // растирать на коже
rus_verbs:переспать{}, // переспал на сеновале
rus_verbs:рассекать{}, // рассекать на скутере
rus_verbs:опровергнуть{}, // опровергнуть на высшем уровне
rus_verbs:дрыхнуть{}, // дрыхнуть на диване
rus_verbs:распять{}, // распять на кресте
rus_verbs:запечься{}, // запечься на костре
rus_verbs:застилать{}, // застилать на балконе
rus_verbs:сыскаться{}, // сыскаться на огороде
rus_verbs:разориться{}, // разориться на продаже спичек
rus_verbs:переделать{}, // переделать на станке
rus_verbs:разъяснять{}, // разъяснять на страницах газеты
rus_verbs:поседеть{}, // поседеть на висках
rus_verbs:протащить{}, // протащить на спине
rus_verbs:осуществиться{}, // осуществиться на деле
rus_verbs:селиться{}, // селиться на окраине
rus_verbs:оплачивать{}, // оплачивать на первой кассе
rus_verbs:переворачивать{}, // переворачивать на сковородке
rus_verbs:упражняться{}, // упражняться на батуте
rus_verbs:испробовать{}, // испробовать на себе
rus_verbs:разгладиться{}, // разгладиться на спине
rus_verbs:рисоваться{}, // рисоваться на стекле
rus_verbs:продрогнуть{}, // продрогнуть на морозе
rus_verbs:пометить{}, // пометить на доске
rus_verbs:приютить{}, // приютить на чердаке
rus_verbs:избирать{}, // избирать на первых свободных выборах
rus_verbs:затеваться{}, // затеваться на матче
rus_verbs:уплывать{}, // уплывать на катере
rus_verbs:замерцать{}, // замерцать на рекламном щите
rus_verbs:фиксироваться{}, // фиксироваться на достигнутом уровне
rus_verbs:запираться{}, // запираться на чердаке
rus_verbs:загубить{}, // загубить на корню
rus_verbs:развеяться{}, // развеяться на природе
rus_verbs:съезжаться{}, // съезжаться на лимузинах
rus_verbs:потанцевать{}, // потанцевать на могиле
rus_verbs:дохнуть{}, // дохнуть на солнце
rus_verbs:припарковаться{}, // припарковаться на газоне
rus_verbs:отхватить{}, // отхватить на распродаже
rus_verbs:остывать{}, // остывать на улице
rus_verbs:переваривать{}, // переваривать на высокой ветке
rus_verbs:подвесить{}, // подвесить на веревке
rus_verbs:хвастать{}, // хвастать на работе
rus_verbs:отрабатывать{}, // отрабатывать на уборке урожая
rus_verbs:разлечься{}, // разлечься на полу
rus_verbs:очертить{}, // очертить на полу
rus_verbs:председательствовать{}, // председательствовать на собрании
rus_verbs:сконфузиться{}, // сконфузиться на сцене
rus_verbs:выявляться{}, // выявляться на ринге
rus_verbs:крутануться{}, // крутануться на заднем колесе
rus_verbs:караулить{}, // караулить на входе
rus_verbs:перечислять{}, // перечислять на пальцах
rus_verbs:обрабатывать{}, // обрабатывать на станке
rus_verbs:настигать{}, // настигать на берегу
rus_verbs:разгуливать{}, // разгуливать на берегу
rus_verbs:насиловать{}, // насиловать на пляже
rus_verbs:поредеть{}, // поредеть на макушке
rus_verbs:учитывать{}, // учитывать на балансе
rus_verbs:зарождаться{}, // зарождаться на большой глубине
rus_verbs:распространять{}, // распространять на сайтах
rus_verbs:пировать{}, // пировать на вершине холма
rus_verbs:начертать{}, // начертать на стене
rus_verbs:расцветать{}, // расцветать на подоконнике
rus_verbs:умнеть{}, // умнеть на глазах
rus_verbs:царствовать{}, // царствовать на окраине
rus_verbs:закрутиться{}, // закрутиться на работе
rus_verbs:отработать{}, // отработать на шахте
rus_verbs:полечь{}, // полечь на поле брани
rus_verbs:щебетать{}, // щебетать на ветке
rus_verbs:подчеркиваться{}, // подчеркиваться на сайте
rus_verbs:посеять{}, // посеять на другом поле
rus_verbs:замечаться{}, // замечаться на пастбище
rus_verbs:просчитать{}, // просчитать на пальцах
rus_verbs:голосовать{}, // голосовать на трассе
rus_verbs:маяться{}, // маяться на пляже
rus_verbs:сколотить{}, // сколотить на службе
rus_verbs:обретаться{}, // обретаться на чужбине
rus_verbs:обливаться{}, // обливаться на улице
rus_verbs:катать{}, // катать на лошадке
rus_verbs:припрятать{}, // припрятать на теле
rus_verbs:запаниковать{}, // запаниковать на экзамене
инфинитив:слетать{ вид:соверш }, глагол:слетать{ вид:соверш }, // слетать на частном самолете
деепричастие:слетав{},
rus_verbs:срубить{}, // срубить денег на спекуляциях
rus_verbs:зажигаться{}, // зажигаться на улице
rus_verbs:жарить{}, // жарить на углях
rus_verbs:накапливаться{}, // накапливаться на счету
rus_verbs:распуститься{}, // распуститься на грядке
rus_verbs:рассаживаться{}, // рассаживаться на местах
rus_verbs:странствовать{}, // странствовать на лошади
rus_verbs:осматриваться{}, // осматриваться на месте
rus_verbs:разворачивать{}, // разворачивать на завоеванной территории
rus_verbs:согревать{}, // согревать на вершине горы
rus_verbs:заскучать{}, // заскучать на вахте
rus_verbs:перекусить{}, // перекусить на бегу
rus_verbs:приплыть{}, // приплыть на тримаране
rus_verbs:зажигать{}, // зажигать на танцах
rus_verbs:закопать{}, // закопать на поляне
rus_verbs:стирать{}, // стирать на берегу
rus_verbs:подстерегать{}, // подстерегать на подходе
rus_verbs:погулять{}, // погулять на свадьбе
rus_verbs:огласить{}, // огласить на митинге
rus_verbs:разбогатеть{}, // разбогатеть на прииске
rus_verbs:грохотать{}, // грохотать на чердаке
rus_verbs:расположить{}, // расположить на границе
rus_verbs:реализоваться{}, // реализоваться на новой работе
rus_verbs:застывать{}, // застывать на морозе
rus_verbs:запечатлеть{}, // запечатлеть на пленке
rus_verbs:тренироваться{}, // тренироваться на манекене
rus_verbs:поспорить{}, // поспорить на совещании
rus_verbs:затягивать{}, // затягивать на поясе
rus_verbs:зиждиться{}, // зиждиться на твердой основе
rus_verbs:построиться{}, // построиться на песке
rus_verbs:надрываться{}, // надрываться на работе
rus_verbs:закипать{}, // закипать на плите
rus_verbs:затонуть{}, // затонуть на мелководье
rus_verbs:побыть{}, // побыть на фазенде
rus_verbs:сгорать{}, // сгорать на солнце
инфинитив:пописать{ aux stress="поп^исать" }, глагол:пописать{ aux stress="поп^исать" }, // пописать на улице
деепричастие:пописав{ aux stress="поп^исав" },
rus_verbs:подраться{}, // подраться на сцене
rus_verbs:заправить{}, // заправить на последней заправке
rus_verbs:обозначаться{}, // обозначаться на карте
rus_verbs:просиживать{}, // просиживать на берегу
rus_verbs:начертить{}, // начертить на листке
rus_verbs:тормозить{}, // тормозить на льду
rus_verbs:затевать{}, // затевать на космической базе
rus_verbs:задерживать{}, // задерживать на таможне
rus_verbs:прилетать{}, // прилетать на частном самолете
rus_verbs:полулежать{}, // полулежать на травке
rus_verbs:ерзать{}, // ерзать на табуретке
rus_verbs:покопаться{}, // покопаться на складе
rus_verbs:подвезти{}, // подвезти на машине
rus_verbs:полежать{}, // полежать на водном матрасе
rus_verbs:стыть{}, // стыть на улице
rus_verbs:стынуть{}, // стынуть на улице
rus_verbs:скреститься{}, // скреститься на груди
rus_verbs:припарковать{}, // припарковать на стоянке
rus_verbs:здороваться{}, // здороваться на кафедре
rus_verbs:нацарапать{}, // нацарапать на парте
rus_verbs:откопать{}, // откопать на поляне
rus_verbs:смастерить{}, // смастерить на коленках
rus_verbs:довезти{}, // довезти на машине
rus_verbs:избивать{}, // избивать на крыше
rus_verbs:сварить{}, // сварить на костре
rus_verbs:истребить{}, // истребить на корню
rus_verbs:раскопать{}, // раскопать на болоте
rus_verbs:попить{}, // попить на кухне
rus_verbs:заправлять{}, // заправлять на базе
rus_verbs:кушать{}, // кушать на кухне
rus_verbs:замолкать{}, // замолкать на половине фразы
rus_verbs:измеряться{}, // измеряться на весах
rus_verbs:сбываться{}, // сбываться на самом деле
rus_verbs:изображаться{}, // изображается на сцене
rus_verbs:фиксировать{}, // фиксировать на данной высоте
rus_verbs:ослаблять{}, // ослаблять на шее
rus_verbs:зреть{}, // зреть на грядке
rus_verbs:зеленеть{}, // зеленеть на грядке
rus_verbs:критиковать{}, // критиковать на страницах газеты
rus_verbs:облететь{}, // облететь на самолете
rus_verbs:заразиться{}, // заразиться на работе
rus_verbs:рассеять{}, // рассеять на территории
rus_verbs:печься{}, // печься на костре
rus_verbs:поспать{}, // поспать на земле
rus_verbs:сплетаться{}, // сплетаться на макушке
rus_verbs:удерживаться{}, // удерживаться на расстоянии
rus_verbs:помешаться{}, // помешаться на чистоте
rus_verbs:ликвидировать{}, // ликвидировать на полигоне
rus_verbs:проваляться{}, // проваляться на диване
rus_verbs:лечиться{}, // лечиться на дому
rus_verbs:обработать{}, // обработать на станке
rus_verbs:защелкнуть{}, // защелкнуть на руках
rus_verbs:разносить{}, // разносить на одежде
rus_verbs:чесать{}, // чесать на груди
rus_verbs:наладить{}, // наладить на конвейере выпуск
rus_verbs:отряхнуться{}, // отряхнуться на улице
rus_verbs:разыгрываться{}, // разыгрываться на скачках
rus_verbs:обеспечиваться{}, // обеспечиваться на выгодных условиях
rus_verbs:греться{}, // греться на вокзале
rus_verbs:засидеться{}, // засидеться на одном месте
rus_verbs:материализоваться{}, // материализоваться на границе
rus_verbs:рассеиваться{}, // рассеиваться на высоте вершин
rus_verbs:перевозить{}, // перевозить на платформе
rus_verbs:поиграть{}, // поиграть на скрипке
rus_verbs:потоптаться{}, // потоптаться на одном месте
rus_verbs:переправиться{}, // переправиться на плоту
rus_verbs:забрезжить{}, // забрезжить на горизонте
rus_verbs:завывать{}, // завывать на опушке
rus_verbs:заваривать{}, // заваривать на кухоньке
rus_verbs:перемещаться{}, // перемещаться на спасательном плоту
инфинитив:писаться{ aux stress="пис^аться" }, глагол:писаться{ aux stress="пис^аться" }, // писаться на бланке
rus_verbs:праздновать{}, // праздновать на улицах
rus_verbs:обучить{}, // обучить на корте
rus_verbs:орудовать{}, // орудовать на складе
rus_verbs:подрасти{}, // подрасти на глядке
rus_verbs:шелестеть{}, // шелестеть на ветру
rus_verbs:раздеваться{}, // раздеваться на публике
rus_verbs:пообедать{}, // пообедать на газоне
rus_verbs:жрать{}, // жрать на помойке
rus_verbs:исполняться{}, // исполняться на флейте
rus_verbs:похолодать{}, // похолодать на улице
rus_verbs:гнить{}, // гнить на каторге
rus_verbs:прослушать{}, // прослушать на концерте
rus_verbs:совещаться{}, // совещаться на заседании
rus_verbs:покачивать{}, // покачивать на волнах
rus_verbs:отсидеть{}, // отсидеть на гаупвахте
rus_verbs:формировать{}, // формировать на секретной базе
rus_verbs:захрапеть{}, // захрапеть на кровати
rus_verbs:объехать{}, // объехать на попутке
rus_verbs:поселить{}, // поселить на верхних этажах
rus_verbs:заворочаться{}, // заворочаться на сене
rus_verbs:напрятать{}, // напрятать на теле
rus_verbs:очухаться{}, // очухаться на земле
rus_verbs:полистать{}, // полистать на досуге
rus_verbs:завертеть{}, // завертеть на шесте
rus_verbs:печатать{}, // печатать на ноуте
rus_verbs:отыскаться{}, // отыскаться на складе
rus_verbs:зафиксировать{}, // зафиксировать на пленке
rus_verbs:расстилаться{}, // расстилаться на столе
rus_verbs:заместить{}, // заместить на посту
rus_verbs:угасать{}, // угасать на неуправляемом корабле
rus_verbs:сразить{}, // сразить на ринге
rus_verbs:расплываться{}, // расплываться на жаре
rus_verbs:сосчитать{}, // сосчитать на пальцах
rus_verbs:сгуститься{}, // сгуститься на небольшой высоте
rus_verbs:цитировать{}, // цитировать на плите
rus_verbs:ориентироваться{}, // ориентироваться на местности
rus_verbs:расширить{}, // расширить на другом конце
rus_verbs:обтереть{}, // обтереть на стоянке
rus_verbs:подстрелить{}, // подстрелить на охоте
rus_verbs:растереть{}, // растереть на твердой поверхности
rus_verbs:подавлять{}, // подавлять на первом этапе
rus_verbs:смешиваться{}, // смешиваться на поверхности
// инфинитив:вычитать{ aux stress="в^ычитать" }, глагол:вычитать{ aux stress="в^ычитать" }, // вычитать на сайте
// деепричастие:вычитав{},
rus_verbs:сократиться{}, // сократиться на втором этапе
rus_verbs:занервничать{}, // занервничать на экзамене
rus_verbs:соприкоснуться{}, // соприкоснуться на трассе
rus_verbs:обозначить{}, // обозначить на плане
rus_verbs:обучаться{}, // обучаться на производстве
rus_verbs:снизиться{}, // снизиться на большой высоте
rus_verbs:простудиться{}, // простудиться на ветру
rus_verbs:поддерживаться{}, // поддерживается на встрече
rus_verbs:уплыть{}, // уплыть на лодочке
rus_verbs:резвиться{}, // резвиться на песочке
rus_verbs:поерзать{}, // поерзать на скамеечке
rus_verbs:похвастаться{}, // похвастаться на встрече
rus_verbs:знакомиться{}, // знакомиться на уроке
rus_verbs:проплывать{}, // проплывать на катере
rus_verbs:засесть{}, // засесть на чердаке
rus_verbs:подцепить{}, // подцепить на дискотеке
rus_verbs:обыскать{}, // обыскать на входе
rus_verbs:оправдаться{}, // оправдаться на суде
rus_verbs:раскрываться{}, // раскрываться на сцене
rus_verbs:одеваться{}, // одеваться на вещевом рынке
rus_verbs:засветиться{}, // засветиться на фотографиях
rus_verbs:употребляться{}, // употребляться на птицефабриках
rus_verbs:грабить{}, // грабить на пустыре
rus_verbs:гонять{}, // гонять на повышенных оборотах
rus_verbs:развеваться{}, // развеваться на древке
rus_verbs:основываться{}, // основываться на безусловных фактах
rus_verbs:допрашивать{}, // допрашивать на базе
rus_verbs:проработать{}, // проработать на стройке
rus_verbs:сосредоточить{}, // сосредоточить на месте
rus_verbs:сочинять{}, // сочинять на ходу
rus_verbs:ползать{}, // ползать на камне
rus_verbs:раскинуться{}, // раскинуться на пустыре
rus_verbs:уставать{}, // уставать на работе
rus_verbs:укрепить{}, // укрепить на конце
rus_verbs:образовывать{}, // образовывать на открытом воздухе взрывоопасную смесь
rus_verbs:одобрять{}, // одобрять на словах
rus_verbs:приговорить{}, // приговорить на заседании тройки
rus_verbs:чернеть{}, // чернеть на свету
rus_verbs:гнуть{}, // гнуть на станке
rus_verbs:размещаться{}, // размещаться на бирже
rus_verbs:соорудить{}, // соорудить на даче
rus_verbs:пастись{}, // пастись на лугу
rus_verbs:формироваться{}, // формироваться на дне
rus_verbs:таить{}, // таить на дне
rus_verbs:приостановиться{}, // приостановиться на середине
rus_verbs:топтаться{}, // топтаться на месте
rus_verbs:громить{}, // громить на подступах
rus_verbs:вычислить{}, // вычислить на бумажке
rus_verbs:заказывать{}, // заказывать на сайте
rus_verbs:осуществить{}, // осуществить на практике
rus_verbs:обосноваться{}, // обосноваться на верхушке
rus_verbs:пытать{}, // пытать на электрическом стуле
rus_verbs:совершиться{}, // совершиться на заседании
rus_verbs:свернуться{}, // свернуться на медленном огне
rus_verbs:пролетать{}, // пролетать на дельтаплане
rus_verbs:сбыться{}, // сбыться на самом деле
rus_verbs:разговориться{}, // разговориться на уроке
rus_verbs:разворачиваться{}, // разворачиваться на перекрестке
rus_verbs:преподнести{}, // преподнести на блюдечке
rus_verbs:напечатать{}, // напечатать на лазернике
rus_verbs:прорвать{}, // прорвать на периферии
rus_verbs:раскачиваться{}, // раскачиваться на доске
rus_verbs:задерживаться{}, // задерживаться на старте
rus_verbs:угощать{}, // угощать на вечеринке
rus_verbs:шарить{}, // шарить на столе
rus_verbs:увеличивать{}, // увеличивать на первом этапе
rus_verbs:рехнуться{}, // рехнуться на старости лет
rus_verbs:расцвести{}, // расцвести на грядке
rus_verbs:закипеть{}, // закипеть на плите
rus_verbs:подлететь{}, // подлететь на параплане
rus_verbs:рыться{}, // рыться на свалке
rus_verbs:добираться{}, // добираться на попутках
rus_verbs:продержаться{}, // продержаться на вершине
rus_verbs:разыскивать{}, // разыскивать на выставках
rus_verbs:освобождать{}, // освобождать на заседании
rus_verbs:передвигаться{}, // передвигаться на самокате
rus_verbs:проявиться{}, // проявиться на свету
rus_verbs:заскользить{}, // заскользить на льду
rus_verbs:пересказать{}, // пересказать на сцене студенческого театра
rus_verbs:протестовать{}, // протестовать на улице
rus_verbs:указываться{}, // указываться на табличках
rus_verbs:прискакать{}, // прискакать на лошадке
rus_verbs:копошиться{}, // копошиться на свежем воздухе
rus_verbs:подсчитать{}, // подсчитать на бумажке
rus_verbs:разволноваться{}, // разволноваться на экзамене
rus_verbs:завертеться{}, // завертеться на полу
rus_verbs:ознакомиться{}, // ознакомиться на ходу
rus_verbs:ржать{}, // ржать на уроке
rus_verbs:раскинуть{}, // раскинуть на грядках
rus_verbs:разгромить{}, // разгромить на ринге
rus_verbs:подслушать{}, // подслушать на совещании
rus_verbs:описываться{}, // описываться на страницах книги
rus_verbs:качаться{}, // качаться на стуле
rus_verbs:усилить{}, // усилить на флангах
rus_verbs:набросать{}, // набросать на клочке картона
rus_verbs:расстреливать{}, // расстреливать на подходе
rus_verbs:запрыгать{}, // запрыгать на одной ноге
rus_verbs:сыскать{}, // сыскать на чужбине
rus_verbs:подтвердиться{}, // подтвердиться на практике
rus_verbs:плескаться{}, // плескаться на мелководье
rus_verbs:расширяться{}, // расширяться на конце
rus_verbs:подержать{}, // подержать на солнце
rus_verbs:планироваться{}, // планироваться на общем собрании
rus_verbs:сгинуть{}, // сгинуть на чужбине
rus_verbs:замкнуться{}, // замкнуться на точке
rus_verbs:закачаться{}, // закачаться на ветру
rus_verbs:перечитывать{}, // перечитывать на ходу
rus_verbs:перелететь{}, // перелететь на дельтаплане
rus_verbs:оживать{}, // оживать на солнце
rus_verbs:женить{}, // женить на богатой невесте
rus_verbs:заглохнуть{}, // заглохнуть на старте
rus_verbs:копаться{}, // копаться на полу
rus_verbs:развлекаться{}, // развлекаться на дискотеке
rus_verbs:печататься{}, // печататься на струйном принтере
rus_verbs:обрываться{}, // обрываться на полуслове
rus_verbs:ускакать{}, // ускакать на лошадке
rus_verbs:подписывать{}, // подписывать на столе
rus_verbs:добывать{}, // добывать на выработке
rus_verbs:скопиться{}, // скопиться на выходе
rus_verbs:повстречать{}, // повстречать на пути
rus_verbs:поцеловаться{}, // поцеловаться на площади
rus_verbs:растянуть{}, // растянуть на столе
rus_verbs:подаваться{}, // подаваться на благотворительном обеде
rus_verbs:повстречаться{}, // повстречаться на митинге
rus_verbs:примоститься{}, // примоститься на ступеньках
rus_verbs:отразить{}, // отразить на страницах доклада
rus_verbs:пояснять{}, // пояснять на страницах приложения
rus_verbs:накормить{}, // накормить на кухне
rus_verbs:поужинать{}, // поужинать на веранде
инфинитив:спеть{ вид:соверш }, глагол:спеть{ вид:соверш }, // спеть на митинге
деепричастие:спев{},
инфинитив:спеть{ вид:несоверш }, глагол:спеть{ вид:несоверш },
rus_verbs:топить{}, // топить на мелководье
rus_verbs:освоить{}, // освоить на практике
rus_verbs:распластаться{}, // распластаться на травке
rus_verbs:отплыть{}, // отплыть на старом каяке
rus_verbs:улетать{}, // улетать на любом самолете
rus_verbs:отстаивать{}, // отстаивать на корте
rus_verbs:осуждать{}, // осуждать на словах
rus_verbs:переговорить{}, // переговорить на обеде
rus_verbs:укрыть{}, // укрыть на чердаке
rus_verbs:томиться{}, // томиться на привязи
rus_verbs:сжигать{}, // сжигать на полигоне
rus_verbs:позавтракать{}, // позавтракать на лоне природы
rus_verbs:функционировать{}, // функционирует на солнечной энергии
rus_verbs:разместить{}, // разместить на сайте
rus_verbs:пронести{}, // пронести на теле
rus_verbs:нашарить{}, // нашарить на столе
rus_verbs:корчиться{}, // корчиться на полу
rus_verbs:распознать{}, // распознать на снимке
rus_verbs:повеситься{}, // повеситься на шнуре
rus_verbs:обозначиться{}, // обозначиться на картах
rus_verbs:оступиться{}, // оступиться на скользком льду
rus_verbs:подносить{}, // подносить на блюдечке
rus_verbs:расстелить{}, // расстелить на газоне
rus_verbs:обсуждаться{}, // обсуждаться на собрании
rus_verbs:расписаться{}, // расписаться на бланке
rus_verbs:плестись{}, // плестись на привязи
rus_verbs:объявиться{}, // объявиться на сцене
rus_verbs:повышаться{}, // повышаться на первом датчике
rus_verbs:разрабатывать{}, // разрабатывать на заводе
rus_verbs:прерывать{}, // прерывать на середине
rus_verbs:каяться{}, // каяться на публике
rus_verbs:освоиться{}, // освоиться на лошади
rus_verbs:подплыть{}, // подплыть на плоту
rus_verbs:оскорбить{}, // оскорбить на митинге
rus_verbs:торжествовать{}, // торжествовать на пьедестале
rus_verbs:поправлять{}, // поправлять на одежде
rus_verbs:отражать{}, // отражать на картине
rus_verbs:дремать{}, // дремать на кушетке
rus_verbs:применяться{}, // применяться на производстве стали
rus_verbs:поражать{}, // поражать на большой дистанции
rus_verbs:расстрелять{}, // расстрелять на окраине хутора
rus_verbs:рассчитать{}, // рассчитать на калькуляторе
rus_verbs:записывать{}, // записывать на ленте
rus_verbs:перебирать{}, // перебирать на ладони
rus_verbs:разбиться{}, // разбиться на катере
rus_verbs:поискать{}, // поискать на ферме
rus_verbs:прятать{}, // прятать на заброшенном складе
rus_verbs:пропеть{}, // пропеть на эстраде
rus_verbs:замелькать{}, // замелькать на экране
rus_verbs:грустить{}, // грустить на веранде
rus_verbs:крутить{}, // крутить на оси
rus_verbs:подготовить{}, // подготовить на конспиративной квартире
rus_verbs:различать{}, // различать на картинке
rus_verbs:киснуть{}, // киснуть на чужбине
rus_verbs:оборваться{}, // оборваться на полуслове
rus_verbs:запутаться{}, // запутаться на простейшем тесте
rus_verbs:общаться{}, // общаться на уроке
rus_verbs:производиться{}, // производиться на фабрике
rus_verbs:сочинить{}, // сочинить на досуге
rus_verbs:давить{}, // давить на лице
rus_verbs:разработать{}, // разработать на секретном предприятии
rus_verbs:качать{}, // качать на качелях
rus_verbs:тушить{}, // тушить на крыше пожар
rus_verbs:охранять{}, // охранять на территории базы
rus_verbs:приметить{}, // приметить на взгорке
rus_verbs:скрыть{}, // скрыть на теле
rus_verbs:удерживать{}, // удерживать на руке
rus_verbs:усвоить{}, // усвоить на уроке
rus_verbs:растаять{}, // растаять на солнечной стороне
rus_verbs:красоваться{}, // красоваться на виду
rus_verbs:сохраняться{}, // сохраняться на холоде
rus_verbs:лечить{}, // лечить на дому
rus_verbs:прокатиться{}, // прокатиться на уницикле
rus_verbs:договариваться{}, // договариваться на нейтральной территории
rus_verbs:качнуться{}, // качнуться на одной ноге
rus_verbs:опубликовать{}, // опубликовать на сайте
rus_verbs:отражаться{}, // отражаться на поверхности воды
rus_verbs:обедать{}, // обедать на веранде
rus_verbs:посидеть{}, // посидеть на лавочке
rus_verbs:сообщаться{}, // сообщаться на официальном сайте
rus_verbs:свершиться{}, // свершиться на заседании
rus_verbs:ночевать{}, // ночевать на даче
rus_verbs:темнеть{}, // темнеть на свету
rus_verbs:гибнуть{}, // гибнуть на территории полигона
rus_verbs:усиливаться{}, // усиливаться на территории округа
rus_verbs:проживать{}, // проживать на даче
rus_verbs:исследовать{}, // исследовать на большой глубине
rus_verbs:обитать{}, // обитать на громадной глубине
rus_verbs:сталкиваться{}, // сталкиваться на большой высоте
rus_verbs:таиться{}, // таиться на большой глубине
rus_verbs:спасать{}, // спасать на пожаре
rus_verbs:сказываться{}, // сказываться на общем результате
rus_verbs:заблудиться{}, // заблудиться на стройке
rus_verbs:пошарить{}, // пошарить на полках
rus_verbs:планировать{}, // планировать на бумаге
rus_verbs:ранить{}, // ранить на полигоне
rus_verbs:хлопать{}, // хлопать на сцене
rus_verbs:основать{}, // основать на горе новый монастырь
rus_verbs:отбить{}, // отбить на столе
rus_verbs:отрицать{}, // отрицать на заседании комиссии
rus_verbs:устоять{}, // устоять на ногах
rus_verbs:отзываться{}, // отзываться на страницах отчёта
rus_verbs:притормозить{}, // притормозить на обочине
rus_verbs:читаться{}, // читаться на лице
rus_verbs:заиграть{}, // заиграть на саксофоне
rus_verbs:зависнуть{}, // зависнуть на игровой площадке
rus_verbs:сознаться{}, // сознаться на допросе
rus_verbs:выясняться{}, // выясняться на очной ставке
rus_verbs:наводить{}, // наводить на столе порядок
rus_verbs:покоиться{}, // покоиться на кладбище
rus_verbs:значиться{}, // значиться на бейджике
rus_verbs:съехать{}, // съехать на санках
rus_verbs:познакомить{}, // познакомить на свадьбе
rus_verbs:завязать{}, // завязать на спине
rus_verbs:грохнуть{}, // грохнуть на площади
rus_verbs:разъехаться{}, // разъехаться на узкой дороге
rus_verbs:столпиться{}, // столпиться на крыльце
rus_verbs:порыться{}, // порыться на полках
rus_verbs:ослабить{}, // ослабить на шее
rus_verbs:оправдывать{}, // оправдывать на суде
rus_verbs:обнаруживаться{}, // обнаруживаться на складе
rus_verbs:спастись{}, // спастись на дереве
rus_verbs:прерваться{}, // прерваться на полуслове
rus_verbs:строиться{}, // строиться на пустыре
rus_verbs:познать{}, // познать на практике
rus_verbs:путешествовать{}, // путешествовать на поезде
rus_verbs:побеждать{}, // побеждать на ринге
rus_verbs:рассматриваться{}, // рассматриваться на заседании
rus_verbs:продаваться{}, // продаваться на открытом рынке
rus_verbs:разместиться{}, // разместиться на базе
rus_verbs:завыть{}, // завыть на холме
rus_verbs:настигнуть{}, // настигнуть на окраине
rus_verbs:укрыться{}, // укрыться на чердаке
rus_verbs:расплакаться{}, // расплакаться на заседании комиссии
rus_verbs:заканчивать{}, // заканчивать на последнем задании
rus_verbs:пролежать{}, // пролежать на столе
rus_verbs:громоздиться{}, // громоздиться на полу
rus_verbs:замерзнуть{}, // замерзнуть на открытом воздухе
rus_verbs:поскользнуться{}, // поскользнуться на льду
rus_verbs:таскать{}, // таскать на спине
rus_verbs:просматривать{}, // просматривать на сайте
rus_verbs:обдумать{}, // обдумать на досуге
rus_verbs:гадать{}, // гадать на кофейной гуще
rus_verbs:останавливать{}, // останавливать на выходе
rus_verbs:обозначать{}, // обозначать на странице
rus_verbs:долететь{}, // долететь на спортивном байке
rus_verbs:тесниться{}, // тесниться на чердачке
rus_verbs:хоронить{}, // хоронить на частном кладбище
rus_verbs:установиться{}, // установиться на юге
rus_verbs:прикидывать{}, // прикидывать на клочке бумаги
rus_verbs:затаиться{}, // затаиться на дереве
rus_verbs:раздобыть{}, // раздобыть на складе
rus_verbs:перебросить{}, // перебросить на вертолетах
rus_verbs:захватывать{}, // захватывать на базе
rus_verbs:сказаться{}, // сказаться на итоговых оценках
rus_verbs:покачиваться{}, // покачиваться на волнах
rus_verbs:крутиться{}, // крутиться на кухне
rus_verbs:помещаться{}, // помещаться на полке
rus_verbs:питаться{}, // питаться на помойке
rus_verbs:отдохнуть{}, // отдохнуть на загородной вилле
rus_verbs:кататься{}, // кататься на велике
rus_verbs:поработать{}, // поработать на стройке
rus_verbs:ограбить{}, // ограбить на пустыре
rus_verbs:зарабатывать{}, // зарабатывать на бирже
rus_verbs:преуспеть{}, // преуспеть на ниве искусства
rus_verbs:заерзать{}, // заерзать на стуле
rus_verbs:разъяснить{}, // разъяснить на полях
rus_verbs:отчеканить{}, // отчеканить на медной пластине
rus_verbs:торговать{}, // торговать на рынке
rus_verbs:поколебаться{}, // поколебаться на пороге
rus_verbs:прикинуть{}, // прикинуть на бумажке
rus_verbs:рассечь{}, // рассечь на тупом конце
rus_verbs:посмеяться{}, // посмеяться на переменке
rus_verbs:остыть{}, // остыть на морозном воздухе
rus_verbs:запереться{}, // запереться на чердаке
rus_verbs:обогнать{}, // обогнать на повороте
rus_verbs:подтянуться{}, // подтянуться на турнике
rus_verbs:привозить{}, // привозить на машине
rus_verbs:подбирать{}, // подбирать на полу
rus_verbs:уничтожать{}, // уничтожать на подходе
rus_verbs:притаиться{}, // притаиться на вершине
rus_verbs:плясать{}, // плясать на костях
rus_verbs:поджидать{}, // поджидать на вокзале
rus_verbs:закончить{}, // Мы закончили игру на самом интересном месте (САМ не может быть первым прилагательным в цепочке!)
rus_verbs:смениться{}, // смениться на посту
rus_verbs:посчитать{}, // посчитать на пальцах
rus_verbs:прицелиться{}, // прицелиться на бегу
rus_verbs:нарисовать{}, // нарисовать на стене
rus_verbs:прыгать{}, // прыгать на сцене
rus_verbs:повертеть{}, // повертеть на пальце
rus_verbs:попрощаться{}, // попрощаться на панихиде
инфинитив:просыпаться{ вид:соверш }, глагол:просыпаться{ вид:соверш }, // просыпаться на диване
rus_verbs:разобрать{}, // разобрать на столе
rus_verbs:помереть{}, // помереть на чужбине
rus_verbs:различить{}, // различить на нечеткой фотографии
rus_verbs:рисовать{}, // рисовать на доске
rus_verbs:проследить{}, // проследить на экране
rus_verbs:задремать{}, // задремать на диване
rus_verbs:ругаться{}, // ругаться на людях
rus_verbs:сгореть{}, // сгореть на работе
rus_verbs:зазвучать{}, // зазвучать на коротких волнах
rus_verbs:задохнуться{}, // задохнуться на вершине горы
rus_verbs:порождать{}, // порождать на поверхности небольшую рябь
rus_verbs:отдыхать{}, // отдыхать на курорте
rus_verbs:образовать{}, // образовать на дне толстый слой
rus_verbs:поправиться{}, // поправиться на дармовых харчах
rus_verbs:отмечать{}, // отмечать на календаре
rus_verbs:реять{}, // реять на флагштоке
rus_verbs:ползти{}, // ползти на коленях
rus_verbs:продавать{}, // продавать на аукционе
rus_verbs:сосредоточиться{}, // сосредоточиться на основной задаче
rus_verbs:рыскать{}, // мышки рыскали на кухне
rus_verbs:расстегнуть{}, // расстегнуть на куртке все пуговицы
rus_verbs:напасть{}, // напасть на территории другого государства
rus_verbs:издать{}, // издать на западе
rus_verbs:оставаться{}, // оставаться на страже порядка
rus_verbs:появиться{}, // наконец появиться на экране
rus_verbs:лежать{}, // лежать на столе
rus_verbs:ждать{}, // ждать на берегу
инфинитив:писать{aux stress="пис^ать"}, // писать на бумаге
глагол:писать{aux stress="пис^ать"},
rus_verbs:оказываться{}, // оказываться на полу
rus_verbs:поставить{}, // поставить на столе
rus_verbs:держать{}, // держать на крючке
rus_verbs:выходить{}, // выходить на остановке
rus_verbs:заговорить{}, // заговорить на китайском языке
rus_verbs:ожидать{}, // ожидать на стоянке
rus_verbs:закричать{}, // закричал на минарете муэдзин
rus_verbs:простоять{}, // простоять на посту
rus_verbs:продолжить{}, // продолжить на первом этаже
rus_verbs:ощутить{}, // ощутить на себе влияние кризиса
rus_verbs:состоять{}, // состоять на учете
rus_verbs:готовиться{},
инфинитив:акклиматизироваться{вид:несоверш}, // альпинисты готовятся акклиматизироваться на новой высоте
глагол:акклиматизироваться{вид:несоверш},
rus_verbs:арестовать{}, // грабители были арестованы на месте преступления
rus_verbs:схватить{}, // грабители были схвачены на месте преступления
инфинитив:атаковать{ вид:соверш }, // взвод был атакован на границе
глагол:атаковать{ вид:соверш },
прилагательное:атакованный{ вид:соверш },
прилагательное:атаковавший{ вид:соверш },
rus_verbs:базировать{}, // установка будет базирована на границе
rus_verbs:базироваться{}, // установка базируется на границе
rus_verbs:барахтаться{}, // дети барахтались на мелководье
rus_verbs:браконьерить{}, // Охотники браконьерили ночью на реке
rus_verbs:браконьерствовать{}, // Охотники ночью браконьерствовали на реке
rus_verbs:бренчать{}, // парень что-то бренчал на гитаре
rus_verbs:бренькать{}, // парень что-то бренькает на гитаре
rus_verbs:начать{}, // Рынок акций РФ начал торги на отрицательной территории.
rus_verbs:буксовать{}, // Колеса буксуют на льду
rus_verbs:вертеться{}, // Непоседливый ученик много вертится на стуле
rus_verbs:взвести{}, // Боец взвел на оружии предохранитель
rus_verbs:вилять{}, // Машина сильно виляла на дороге
rus_verbs:висеть{}, // Яблоко висит на ветке
rus_verbs:возлежать{}, // возлежать на лежанке
rus_verbs:подниматься{}, // Мы поднимаемся на лифте
rus_verbs:подняться{}, // Мы поднимемся на лифте
rus_verbs:восседать{}, // Коля восседает на лошади
rus_verbs:воссиять{}, // Луна воссияла на небе
rus_verbs:воцариться{}, // Мир воцарился на всей земле
rus_verbs:воцаряться{}, // Мир воцаряется на всей земле
rus_verbs:вращать{}, // вращать на поясе
rus_verbs:вращаться{}, // вращаться на поясе
rus_verbs:встретить{}, // встретить друга на улице
rus_verbs:встретиться{}, // встретиться на занятиях
rus_verbs:встречать{}, // встречать на занятиях
rus_verbs:въебывать{}, // въебывать на работе
rus_verbs:въезжать{}, // въезжать на автомобиле
rus_verbs:въехать{}, // въехать на автомобиле
rus_verbs:выгорать{}, // ткань выгорает на солнце
rus_verbs:выгореть{}, // ткань выгорела на солнце
rus_verbs:выгравировать{}, // выгравировать на табличке надпись
rus_verbs:выжить{}, // выжить на необитаемом острове
rus_verbs:вылежаться{}, // помидоры вылежались на солнце
rus_verbs:вылеживаться{}, // вылеживаться на солнце
rus_verbs:выместить{}, // выместить на ком-то злобу
rus_verbs:вымещать{}, // вымещать на ком-то свое раздражение
rus_verbs:вымещаться{}, // вымещаться на ком-то
rus_verbs:выращивать{}, // выращивать на грядке помидоры
rus_verbs:выращиваться{}, // выращиваться на грядке
инфинитив:вырезать{вид:соверш}, // вырезать на доске надпись
глагол:вырезать{вид:соверш},
инфинитив:вырезать{вид:несоверш},
глагол:вырезать{вид:несоверш},
rus_verbs:вырисоваться{}, // вырисоваться на графике
rus_verbs:вырисовываться{}, // вырисовываться на графике
rus_verbs:высаживать{}, // высаживать на необитаемом острове
rus_verbs:высаживаться{}, // высаживаться на острове
rus_verbs:высвечивать{}, // высвечивать на дисплее температуру
rus_verbs:высвечиваться{}, // высвечиваться на дисплее
rus_verbs:выстроить{}, // выстроить на фундаменте
rus_verbs:выстроиться{}, // выстроиться на плацу
rus_verbs:выстудить{}, // выстудить на морозе
rus_verbs:выстудиться{}, // выстудиться на морозе
rus_verbs:выстужать{}, // выстужать на морозе
rus_verbs:выстуживать{}, // выстуживать на морозе
rus_verbs:выстуживаться{}, // выстуживаться на морозе
rus_verbs:выстукать{}, // выстукать на клавиатуре
rus_verbs:выстукивать{}, // выстукивать на клавиатуре
rus_verbs:выстукиваться{}, // выстукиваться на клавиатуре
rus_verbs:выступать{}, // выступать на сцене
rus_verbs:выступить{}, // выступить на сцене
rus_verbs:выстучать{}, // выстучать на клавиатуре
rus_verbs:выстывать{}, // выстывать на морозе
rus_verbs:выстыть{}, // выстыть на морозе
rus_verbs:вытатуировать{}, // вытатуировать на руке якорь
rus_verbs:говорить{}, // говорить на повышенных тонах
rus_verbs:заметить{}, // заметить на берегу
rus_verbs:стоять{}, // твёрдо стоять на ногах
rus_verbs:оказаться{}, // оказаться на передовой линии
rus_verbs:почувствовать{}, // почувствовать на своей шкуре
rus_verbs:остановиться{}, // остановиться на первом пункте
rus_verbs:показаться{}, // показаться на горизонте
rus_verbs:чувствовать{}, // чувствовать на своей шкуре
rus_verbs:искать{}, // искать на открытом пространстве
rus_verbs:иметься{}, // иметься на складе
rus_verbs:клясться{}, // клясться на Коране
rus_verbs:прервать{}, // прервать на полуслове
rus_verbs:играть{}, // играть на чувствах
rus_verbs:спуститься{}, // спуститься на парашюте
rus_verbs:понадобиться{}, // понадобиться на экзамене
rus_verbs:служить{}, // служить на флоте
rus_verbs:подобрать{}, // подобрать на улице
rus_verbs:появляться{}, // появляться на сцене
rus_verbs:селить{}, // селить на чердаке
rus_verbs:поймать{}, // поймать на границе
rus_verbs:увидать{}, // увидать на опушке
rus_verbs:подождать{}, // подождать на перроне
rus_verbs:прочесть{}, // прочесть на полях
rus_verbs:тонуть{}, // тонуть на мелководье
rus_verbs:ощущать{}, // ощущать на коже
rus_verbs:отметить{}, // отметить на полях
rus_verbs:показывать{}, // показывать на графике
rus_verbs:разговаривать{}, // разговаривать на иностранном языке
rus_verbs:прочитать{}, // прочитать на сайте
rus_verbs:попробовать{}, // попробовать на практике
rus_verbs:замечать{}, // замечать на коже грязь
rus_verbs:нести{}, // нести на плечах
rus_verbs:носить{}, // носить на голове
rus_verbs:гореть{}, // гореть на работе
rus_verbs:застыть{}, // застыть на пороге
инфинитив:жениться{ вид:соверш }, // жениться на королеве
глагол:жениться{ вид:соверш },
прилагательное:женатый{},
прилагательное:женившийся{},
rus_verbs:спрятать{}, // спрятать на чердаке
rus_verbs:развернуться{}, // развернуться на плацу
rus_verbs:строить{}, // строить на песке
rus_verbs:устроить{}, // устроить на даче тестральный вечер
rus_verbs:настаивать{}, // настаивать на выполнении приказа
rus_verbs:находить{}, // находить на берегу
rus_verbs:мелькнуть{}, // мелькнуть на экране
rus_verbs:очутиться{}, // очутиться на опушке леса
инфинитив:использовать{вид:соверш}, // использовать на работе
глагол:использовать{вид:соверш},
инфинитив:использовать{вид:несоверш},
глагол:использовать{вид:несоверш},
прилагательное:использованный{},
прилагательное:использующий{},
прилагательное:использовавший{},
rus_verbs:лететь{}, // лететь на воздушном шаре
rus_verbs:смеяться{}, // смеяться на сцене
rus_verbs:ездить{}, // ездить на мопеде
rus_verbs:заснуть{}, // заснуть на диване
rus_verbs:застать{}, // застать на рабочем месте
rus_verbs:очнуться{}, // очнуться на больничной койке
rus_verbs:разглядеть{}, // разглядеть на фотографии
rus_verbs:обойти{}, // обойти на вираже
rus_verbs:удержаться{}, // удержаться на троне
rus_verbs:побывать{}, // побывать на другой планете
rus_verbs:заняться{}, // заняться на выходных делом
rus_verbs:вянуть{}, // вянуть на солнце
rus_verbs:постоять{}, // постоять на голове
rus_verbs:приобрести{}, // приобрести на распродаже
rus_verbs:попасться{}, // попасться на краже
rus_verbs:продолжаться{}, // продолжаться на земле
rus_verbs:открывать{}, // открывать на арене
rus_verbs:создавать{}, // создавать на сцене
rus_verbs:обсуждать{}, // обсуждать на кухне
rus_verbs:отыскать{}, // отыскать на полу
rus_verbs:уснуть{}, // уснуть на диване
rus_verbs:задержаться{}, // задержаться на работе
rus_verbs:курить{}, // курить на свежем воздухе
rus_verbs:приподняться{}, // приподняться на локтях
rus_verbs:установить{}, // установить на вершине
rus_verbs:запереть{}, // запереть на балконе
rus_verbs:синеть{}, // синеть на воздухе
rus_verbs:убивать{}, // убивать на нейтральной территории
rus_verbs:скрываться{}, // скрываться на даче
rus_verbs:родить{}, // родить на полу
rus_verbs:описать{}, // описать на страницах книги
rus_verbs:перехватить{}, // перехватить на подлете
rus_verbs:скрывать{}, // скрывать на даче
rus_verbs:сменить{}, // сменить на посту
rus_verbs:мелькать{}, // мелькать на экране
rus_verbs:присутствовать{}, // присутствовать на мероприятии
rus_verbs:украсть{}, // украсть на рынке
rus_verbs:победить{}, // победить на ринге
rus_verbs:упомянуть{}, // упомянуть на страницах романа
rus_verbs:плыть{}, // плыть на старой лодке
rus_verbs:повиснуть{}, // повиснуть на перекладине
rus_verbs:нащупать{}, // нащупать на дне
rus_verbs:затихнуть{}, // затихнуть на дне
rus_verbs:построить{}, // построить на участке
rus_verbs:поддерживать{}, // поддерживать на поверхности
rus_verbs:заработать{}, // заработать на бирже
rus_verbs:провалиться{}, // провалиться на экзамене
rus_verbs:сохранить{}, // сохранить на диске
rus_verbs:располагаться{}, // располагаться на софе
rus_verbs:поклясться{}, // поклясться на библии
rus_verbs:сражаться{}, // сражаться на арене
rus_verbs:спускаться{}, // спускаться на дельтаплане
rus_verbs:уничтожить{}, // уничтожить на подступах
rus_verbs:изучить{}, // изучить на практике
rus_verbs:рождаться{}, // рождаться на праздниках
rus_verbs:прилететь{}, // прилететь на самолете
rus_verbs:догнать{}, // догнать на перекрестке
rus_verbs:изобразить{}, // изобразить на бумаге
rus_verbs:проехать{}, // проехать на тракторе
rus_verbs:приготовить{}, // приготовить на масле
rus_verbs:споткнуться{}, // споткнуться на полу
rus_verbs:собирать{}, // собирать на берегу
rus_verbs:отсутствовать{}, // отсутствовать на тусовке
rus_verbs:приземлиться{}, // приземлиться на военном аэродроме
rus_verbs:сыграть{}, // сыграть на трубе
rus_verbs:прятаться{}, // прятаться на даче
rus_verbs:спрятаться{}, // спрятаться на чердаке
rus_verbs:провозгласить{}, // провозгласить на митинге
rus_verbs:изложить{}, // изложить на бумаге
rus_verbs:использоваться{}, // использоваться на практике
rus_verbs:замяться{}, // замяться на входе
rus_verbs:раздаваться{}, // Крик ягуара раздается на краю болота
rus_verbs:сверкнуть{}, // сверкнуть на солнце
rus_verbs:сверкать{}, // сверкать на свету
rus_verbs:задержать{}, // задержать на митинге
rus_verbs:осечься{}, // осечься на первом слове
rus_verbs:хранить{}, // хранить на банковском счету
rus_verbs:шутить{}, // шутить на уроке
rus_verbs:кружиться{}, // кружиться на балу
rus_verbs:чертить{}, // чертить на доске
rus_verbs:отразиться{}, // отразиться на оценках
rus_verbs:греть{}, // греть на солнце
rus_verbs:рассуждать{}, // рассуждать на страницах своей книги
rus_verbs:окружать{}, // окружать на острове
rus_verbs:сопровождать{}, // сопровождать на охоте
rus_verbs:заканчиваться{}, // заканчиваться на самом интересном месте
rus_verbs:содержаться{}, // содержаться на приусадебном участке
rus_verbs:поселиться{}, // поселиться на даче
rus_verbs:запеть{}, // запеть на сцене
инфинитив:провозить{ вид:несоверш }, // провозить на теле
глагол:провозить{ вид:несоверш },
прилагательное:провезенный{},
прилагательное:провозивший{вид:несоверш},
прилагательное:провозящий{вид:несоверш},
деепричастие:провозя{},
rus_verbs:мочить{}, // мочить на месте
rus_verbs:преследовать{}, // преследовать на территории другого штата
rus_verbs:пролететь{}, // пролетел на параплане
rus_verbs:драться{}, // драться на рапирах
rus_verbs:просидеть{}, // просидеть на занятиях
rus_verbs:убираться{}, // убираться на балконе
rus_verbs:таять{}, // таять на солнце
rus_verbs:проверять{}, // проверять на полиграфе
rus_verbs:убеждать{}, // убеждать на примере
rus_verbs:скользить{}, // скользить на льду
rus_verbs:приобретать{}, // приобретать на распродаже
rus_verbs:летать{}, // летать на метле
rus_verbs:толпиться{}, // толпиться на перроне
rus_verbs:плавать{}, // плавать на надувном матрасе
rus_verbs:описывать{}, // описывать на страницах повести
rus_verbs:пробыть{}, // пробыть на солнце слишком долго
rus_verbs:застрять{}, // застрять на верхнем этаже
rus_verbs:метаться{}, // метаться на полу
rus_verbs:сжечь{}, // сжечь на костре
rus_verbs:расслабиться{}, // расслабиться на кушетке
rus_verbs:услыхать{}, // услыхать на рынке
rus_verbs:удержать{}, // удержать на прежнем уровне
rus_verbs:образоваться{}, // образоваться на дне
rus_verbs:рассмотреть{}, // рассмотреть на поверхности чипа
rus_verbs:уезжать{}, // уезжать на попутке
rus_verbs:похоронить{}, // похоронить на закрытом кладбище
rus_verbs:настоять{}, // настоять на пересмотре оценок
rus_verbs:растянуться{}, // растянуться на горячем песке
rus_verbs:покрутить{}, // покрутить на шесте
rus_verbs:обнаружиться{}, // обнаружиться на болоте
rus_verbs:гулять{}, // гулять на свадьбе
rus_verbs:утонуть{}, // утонуть на курорте
rus_verbs:храниться{}, // храниться на депозите
rus_verbs:танцевать{}, // танцевать на свадьбе
rus_verbs:трудиться{}, // трудиться на заводе
инфинитив:засыпать{переходность:непереходный вид:несоверш}, // засыпать на кровати
глагол:засыпать{переходность:непереходный вид:несоверш},
деепричастие:засыпая{переходность:непереходный вид:несоверш},
прилагательное:засыпавший{переходность:непереходный вид:несоверш},
прилагательное:засыпающий{ вид:несоверш переходность:непереходный }, // ребенок, засыпающий на руках
rus_verbs:сушить{}, // сушить на открытом воздухе
rus_verbs:зашевелиться{}, // зашевелиться на чердаке
rus_verbs:обдумывать{}, // обдумывать на досуге
rus_verbs:докладывать{}, // докладывать на научной конференции
rus_verbs:промелькнуть{}, // промелькнуть на экране
// прилагательное:находящийся{ вид:несоверш }, // колонна, находящаяся на ничейной территории
прилагательное:написанный{}, // слово, написанное на заборе
rus_verbs:умещаться{}, // компьютер, умещающийся на ладони
rus_verbs:открыть{}, // книга, открытая на последней странице
rus_verbs:спать{}, // йог, спящий на гвоздях
rus_verbs:пробуксовывать{}, // колесо, пробуксовывающее на обледенелом асфальте
rus_verbs:забуксовать{}, // колесо, забуксовавшее на обледенелом асфальте
rus_verbs:отобразиться{}, // удивление, отобразившееся на лице
rus_verbs:увидеть{}, // на полу я увидел чьи-то следы
rus_verbs:видеть{}, // на полу я вижу чьи-то следы
rus_verbs:оставить{}, // Мел оставил на доске белый след.
rus_verbs:оставлять{}, // Мел оставляет на доске белый след.
rus_verbs:встречаться{}, // встречаться на лекциях
rus_verbs:познакомиться{}, // познакомиться на занятиях
rus_verbs:устроиться{}, // она устроилась на кровати
rus_verbs:ложиться{}, // ложись на полу
rus_verbs:останавливаться{}, // останавливаться на достигнутом
rus_verbs:спотыкаться{}, // спотыкаться на ровном месте
rus_verbs:распечатать{}, // распечатать на бумаге
rus_verbs:распечатывать{}, // распечатывать на бумаге
rus_verbs:просмотреть{}, // просмотреть на бумаге
rus_verbs:закрепляться{}, // закрепляться на плацдарме
rus_verbs:погреться{}, // погреться на солнышке
rus_verbs:мешать{}, // Он мешал краски на палитре.
rus_verbs:занять{}, // Он занял первое место на соревнованиях.
rus_verbs:заговариваться{}, // Он заговаривался иногда на уроках.
деепричастие:женившись{ вид:соверш },
rus_verbs:везти{}, // Он везёт песок на тачке.
прилагательное:казненный{}, // Он был казнён на электрическом стуле.
rus_verbs:прожить{}, // Он безвыездно прожил всё лето на даче.
rus_verbs:принести{}, // Официантка принесла нам обед на подносе.
rus_verbs:переписать{}, // Перепишите эту рукопись на машинке.
rus_verbs:идти{}, // Поезд идёт на малой скорости.
rus_verbs:петь{}, // птички поют на рассвете
rus_verbs:смотреть{}, // Смотри на обороте.
rus_verbs:прибрать{}, // прибрать на столе
rus_verbs:прибраться{}, // прибраться на столе
rus_verbs:растить{}, // растить капусту на огороде
rus_verbs:тащить{}, // тащить ребенка на руках
rus_verbs:убирать{}, // убирать на столе
rus_verbs:простыть{}, // Я простыл на морозе.
rus_verbs:сиять{}, // ясные звезды мирно сияли на безоблачном весеннем небе.
rus_verbs:проводиться{}, // такие эксперименты не проводятся на воде
rus_verbs:достать{}, // Я не могу достать до яблок на верхних ветках.
rus_verbs:расплыться{}, // Чернила расплылись на плохой бумаге.
rus_verbs:вскочить{}, // У него вскочил прыщ на носу.
rus_verbs:свить{}, // У нас на балконе воробей свил гнездо.
rus_verbs:оторваться{}, // У меня на пальто оторвалась пуговица.
rus_verbs:восходить{}, // Солнце восходит на востоке.
rus_verbs:блестеть{}, // Снег блестит на солнце.
rus_verbs:побить{}, // Рысак побил всех лошадей на скачках.
rus_verbs:литься{}, // Реки крови льются на войне.
rus_verbs:держаться{}, // Ребёнок уже твёрдо держится на ногах.
rus_verbs:клубиться{}, // Пыль клубится на дороге.
инфинитив:написать{ aux stress="напис^ать" }, // Ты должен написать статью на английском языке
глагол:написать{ aux stress="напис^ать" }, // Он написал статью на русском языке.
// глагол:находиться{вид:несоверш}, // мой поезд находится на первом пути
// инфинитив:находиться{вид:несоверш},
rus_verbs:жить{}, // Было интересно жить на курорте.
rus_verbs:повидать{}, // Он много повидал на своём веку.
rus_verbs:разъезжаться{}, // Ноги разъезжаются не только на льду.
rus_verbs:расположиться{}, // Оба села расположились на берегу реки.
rus_verbs:объясняться{}, // Они объясняются на иностранном языке.
rus_verbs:прощаться{}, // Они долго прощались на вокзале.
rus_verbs:работать{}, // Она работает на ткацкой фабрике.
rus_verbs:купить{}, // Она купила молоко на рынке.
rus_verbs:поместиться{}, // Все книги поместились на полке.
глагол:проводить{вид:несоверш}, инфинитив:проводить{вид:несоверш}, // Нужно проводить теорию на практике.
rus_verbs:пожить{}, // Недолго она пожила на свете.
rus_verbs:краснеть{}, // Небо краснеет на закате.
rus_verbs:бывать{}, // На Волге бывает сильное волнение.
rus_verbs:ехать{}, // Мы туда ехали на автобусе.
rus_verbs:провести{}, // Мы провели месяц на даче.
rus_verbs:поздороваться{}, // Мы поздоровались при встрече на улице.
rus_verbs:расти{}, // Арбузы растут теперь не только на юге.
ГЛ_ИНФ(сидеть), // три больших пса сидят на траве
ГЛ_ИНФ(сесть), // три больших пса сели на траву
ГЛ_ИНФ(перевернуться), // На дороге перевернулся автомобиль
ГЛ_ИНФ(повезти), // я повезу тебя на машине
ГЛ_ИНФ(отвезти), // мы отвезем тебя на такси
ГЛ_ИНФ(пить), // пить на кухне чай
ГЛ_ИНФ(найти), // найти на острове
ГЛ_ИНФ(быть), // на этих костях есть следы зубов
ГЛ_ИНФ(высадиться), // помощники высадились на острове
ГЛ_ИНФ(делать),прилагательное:делающий{}, прилагательное:делавший{}, деепричастие:делая{}, // смотрю фильм о том, что пираты делали на необитаемом острове
ГЛ_ИНФ(случиться), // это случилось на опушке леса
ГЛ_ИНФ(продать),
ГЛ_ИНФ(есть) // кошки ели мой корм на песчаном берегу
}
#endregion VerbList
// Чтобы разрешить связывание в паттернах типа: смотреть на youtube
fact гл_предл
{
if context { Гл_НА_Предл предлог:в{} @regex("[a-z]+[0-9]*") }
then return true
}
fact гл_предл
{
if context { Гл_НА_Предл предлог:на{} *:*{падеж:предл} }
then return true
}
// локатив
fact гл_предл
{
if context { Гл_НА_Предл предлог:на{} *:*{падеж:мест} }
then return true
}
#endregion ПРЕДЛОЖНЫЙ
#region ВИНИТЕЛЬНЫЙ
// НА+винительный падеж:
// ЗАБИРАТЬСЯ НА ВЕРШИНУ ГОРЫ
#region VerbList
wordentry_set Гл_НА_Вин=
{
rus_verbs:переметнуться{}, // Ее взгляд растерянно переметнулся на Лили.
rus_verbs:отогнать{}, // Водитель отогнал машину на стоянку.
rus_verbs:фапать{}, // Не фапай на желтяк и не перебивай.
rus_verbs:умножить{}, // Умножьте это количество примерно на 10.
//rus_verbs:умножать{},
rus_verbs:откатить{}, // Откатил Шпак валун на шлях и перекрыл им дорогу.
rus_verbs:откатывать{},
rus_verbs:доносить{}, // Вот и побежали на вас доносить.
rus_verbs:донести{},
rus_verbs:разбирать{}, // Ворованные автомобили злоумышленники разбирали на запчасти и продавали.
безлич_глагол:хватит{}, // - На одну атаку хватит.
rus_verbs:скупиться{}, // Он сражался за жизнь, не скупясь на хитрости и усилия, и пока этот стиль давал неплохие результаты.
rus_verbs:поскупиться{}, // Не поскупись на похвалы!
rus_verbs:подыматься{},
rus_verbs:транспортироваться{},
rus_verbs:бахнуть{}, // Бахнуть стакан на пол
rus_verbs:РАЗДЕЛИТЬ{}, // Президентские выборы разделили Венесуэлу на два непримиримых лагеря (РАЗДЕЛИТЬ)
rus_verbs:НАЦЕЛИВАТЬСЯ{}, // Невдалеке пролетел кондор, нацеливаясь на бизонью тушу. (НАЦЕЛИВАТЬСЯ)
rus_verbs:ВЫПЛЕСНУТЬ{}, // Низкий вибрирующий гул напоминал вулкан, вот-вот готовый выплеснуть на земную твердь потоки раскаленной лавы. (ВЫПЛЕСНУТЬ)
rus_verbs:ИСЧЕЗНУТЬ{}, // Оно фыркнуло и исчезло в лесу на другой стороне дороги (ИСЧЕЗНУТЬ)
rus_verbs:ВЫЗВАТЬ{}, // вызвать своего брата на поединок. (ВЫЗВАТЬ)
rus_verbs:ПОБРЫЗГАТЬ{}, // Матрос побрызгал немного фимиама на крошечный огонь (ПОБРЫЗГАТЬ/БРЫЗГАТЬ/БРЫЗНУТЬ/КАПНУТЬ/КАПАТЬ/ПОКАПАТЬ)
rus_verbs:БРЫЗГАТЬ{},
rus_verbs:БРЫЗНУТЬ{},
rus_verbs:КАПНУТЬ{},
rus_verbs:КАПАТЬ{},
rus_verbs:ПОКАПАТЬ{},
rus_verbs:ПООХОТИТЬСЯ{}, // Мы можем когда-нибудь вернуться и поохотиться на него. (ПООХОТИТЬСЯ/ОХОТИТЬСЯ)
rus_verbs:ОХОТИТЬСЯ{}, //
rus_verbs:ПОПАСТЬСЯ{}, // Не думал я, что они попадутся на это (ПОПАСТЬСЯ/НАРВАТЬСЯ/НАТОЛКНУТЬСЯ)
rus_verbs:НАРВАТЬСЯ{}, //
rus_verbs:НАТОЛКНУТЬСЯ{}, //
rus_verbs:ВЫСЛАТЬ{}, // Он выслал разведчиков на большое расстояние от основного отряда. (ВЫСЛАТЬ)
прилагательное:ПОХОЖИЙ{}, // Ты не выглядишь похожим на индейца (ПОХОЖИЙ)
rus_verbs:РАЗОРВАТЬ{}, // Через минуту он был мертв и разорван на части. (РАЗОРВАТЬ)
rus_verbs:СТОЛКНУТЬ{}, // Только быстрыми выпадами копья он сумел столкнуть их обратно на карниз. (СТОЛКНУТЬ/СТАЛКИВАТЬ)
rus_verbs:СТАЛКИВАТЬ{}, //
rus_verbs:СПУСТИТЬ{}, // Я побежал к ним, но они к тому времени спустили лодку на воду (СПУСТИТЬ)
rus_verbs:ПЕРЕБРАСЫВАТЬ{}, // Сирия перебрасывает на юг страны воинские подкрепления (ПЕРЕБРАСЫВАТЬ, ПЕРЕБРОСИТЬ, НАБРАСЫВАТЬ, НАБРОСИТЬ)
rus_verbs:ПЕРЕБРОСИТЬ{}, //
rus_verbs:НАБРАСЫВАТЬ{}, //
rus_verbs:НАБРОСИТЬ{}, //
rus_verbs:СВЕРНУТЬ{}, // Он вывел машину на бульвар и поехал на восток, а затем свернул на юг. (СВЕРНУТЬ/СВОРАЧИВАТЬ/ПОВЕРНУТЬ/ПОВОРАЧИВАТЬ)
rus_verbs:СВОРАЧИВАТЬ{}, // //
rus_verbs:ПОВЕРНУТЬ{}, //
rus_verbs:ПОВОРАЧИВАТЬ{}, //
rus_verbs:наорать{},
rus_verbs:ПРОДВИНУТЬСЯ{}, // Полк продвинется на десятки километров (ПРОДВИНУТЬСЯ)
rus_verbs:БРОСАТЬ{}, // Он бросает обещания на ветер (БРОСАТЬ)
rus_verbs:ОДОЛЖИТЬ{}, // Я вам одолжу книгу на десять дней (ОДОЛЖИТЬ)
rus_verbs:перегнать{}, // Скот нужно перегнать с этого пастбища на другое
rus_verbs:перегонять{},
rus_verbs:выгонять{},
rus_verbs:выгнать{},
rus_verbs:СВОДИТЬСЯ{}, // сейчас панели кузовов расходятся по десяткам покрасочных постов и потом сводятся вновь на общий конвейер (СВОДИТЬСЯ)
rus_verbs:ПОЖЕРТВОВАТЬ{}, // Бывший функционер компартии Эстонии пожертвовал деньги на расследования преступлений коммунизма (ПОЖЕРТВОВАТЬ)
rus_verbs:ПРОВЕРЯТЬ{}, // Школьников будут принудительно проверять на курение (ПРОВЕРЯТЬ)
rus_verbs:ОТПУСТИТЬ{}, // Приставы отпустят должников на отдых (ОТПУСТИТЬ)
rus_verbs:использоваться{}, // имеющийся у государства денежный запас активно используется на поддержание рынка акций
rus_verbs:назначаться{}, // назначаться на пост
rus_verbs:наблюдать{}, // Судья , долго наблюдавший в трубу , вдруг вскричал
rus_verbs:ШПИОНИТЬ{}, // Канадского офицера, шпионившего на Россию, приговорили к 20 годам тюрьмы (ШПИОНИТЬ НА вин)
rus_verbs:ЗАПЛАНИРОВАТЬ{}, // все деньги , запланированные на сейсмоукрепление домов на Камчатке (ЗАПЛАНИРОВАТЬ НА)
// rus_verbs:ПОХОДИТЬ{}, // больше походил на обвинительную речь , адресованную руководству республики (ПОХОДИТЬ НА)
rus_verbs:ДЕЙСТВОВАТЬ{}, // выявленный контрабандный канал действовал на постоянной основе (ДЕЙСТВОВАТЬ НА)
rus_verbs:ПЕРЕДАТЬ{}, // после чего должно быть передано на рассмотрение суда (ПЕРЕДАТЬ НА вин)
rus_verbs:НАЗНАЧИТЬСЯ{}, // Зимой на эту должность пытался назначиться народный депутат (НАЗНАЧИТЬСЯ НА)
rus_verbs:РЕШИТЬСЯ{}, // Франция решилась на одностороннее и рискованное военное вмешательство (РЕШИТЬСЯ НА)
rus_verbs:ОРИЕНТИРОВАТЬ{}, // Этот браузер полностью ориентирован на планшеты и сенсорный ввод (ОРИЕНТИРОВАТЬ НА вин)
rus_verbs:ЗАВЕСТИ{}, // на Витьку завели дело (ЗАВЕСТИ НА)
rus_verbs:ОБРУШИТЬСЯ{}, // В Северной Осетии на воинскую часть обрушилась снежная лавина (ОБРУШИТЬСЯ В, НА)
rus_verbs:НАСТРАИВАТЬСЯ{}, // гетеродин, настраивающийся на волну (НАСТРАИВАТЬСЯ НА)
rus_verbs:СУЩЕСТВОВАТЬ{}, // Он существует на средства родителей. (СУЩЕСТВОВАТЬ НА)
прилагательное:способный{}, // Он способен на убийство. (СПОСОБНЫЙ НА)
rus_verbs:посыпаться{}, // на Нину посыпались снежинки
инфинитив:нарезаться{ вид:несоверш }, // Урожай собирают механически или вручную, стебли нарезаются на куски и быстро транспортируются на перерабатывающий завод.
глагол:нарезаться{ вид:несоверш },
rus_verbs:пожаловать{}, // скандально известный певец пожаловал к нам на передачу
rus_verbs:показать{}, // Вадим показал на Колю
rus_verbs:съехаться{}, // Финалисты съехались на свои игры в Лос-Анжелес. (СЪЕХАТЬСЯ НА, В)
rus_verbs:расщепляться{}, // Сахароза же быстро расщепляется в пищеварительном тракте на глюкозу и фруктозу (РАСЩЕПЛЯТЬСЯ В, НА)
rus_verbs:упасть{}, // В Таиланде на автобус с российскими туристами упал башенный кран (УПАСТЬ В, НА)
прилагательное:тугой{}, // Бабушка туга на ухо. (ТУГОЙ НА)
rus_verbs:свисать{}, // Волосы свисают на лоб. (свисать на)
rus_verbs:ЦЕНИТЬСЯ{}, // Всякая рабочая рука ценилась на вес золота. (ЦЕНИТЬСЯ НА)
rus_verbs:ШУМЕТЬ{}, // Вы шумите на весь дом! (ШУМЕТЬ НА)
rus_verbs:протянуться{}, // Дорога протянулась на сотни километров. (протянуться на)
rus_verbs:РАССЧИТАТЬ{}, // Книга рассчитана на массового читателя. (РАССЧИТАТЬ НА)
rus_verbs:СОРИЕНТИРОВАТЬ{}, // мы сориентировали процесс на повышение котировок (СОРИЕНТИРОВАТЬ НА)
rus_verbs:рыкнуть{}, // рыкнуть на остальных членов стаи (рыкнуть на)
rus_verbs:оканчиваться{}, // оканчиваться на звонкую согласную (оканчиваться на)
rus_verbs:выехать{}, // посигналить нарушителю, выехавшему на встречную полосу (выехать на)
rus_verbs:прийтись{}, // Пятое число пришлось на субботу.
rus_verbs:крениться{}, // корабль кренился на правый борт (крениться на)
rus_verbs:приходиться{}, // основной налоговый гнет приходится на средний бизнес (приходиться на)
rus_verbs:верить{}, // верить людям на слово (верить на слово)
rus_verbs:выезжать{}, // Завтра вся семья выезжает на новую квартиру.
rus_verbs:записать{}, // Запишите меня на завтрашний приём к доктору.
rus_verbs:пасть{}, // Жребий пал на меня.
rus_verbs:ездить{}, // Вчера мы ездили на оперу.
rus_verbs:влезть{}, // Мальчик влез на дерево.
rus_verbs:выбежать{}, // Мальчик выбежал из комнаты на улицу.
rus_verbs:разбиться{}, // окно разбилось на мелкие осколки
rus_verbs:бежать{}, // я бегу на урок
rus_verbs:сбегаться{}, // сбегаться на происшествие
rus_verbs:присылать{}, // присылать на испытание
rus_verbs:надавить{}, // надавить на педать
rus_verbs:внести{}, // внести законопроект на рассмотрение
rus_verbs:вносить{}, // вносить законопроект на рассмотрение
rus_verbs:поворачиваться{}, // поворачиваться на 180 градусов
rus_verbs:сдвинуть{}, // сдвинуть на несколько сантиметров
rus_verbs:опубликовать{}, // С.Митрохин опубликовал компромат на думских подельников Гудкова
rus_verbs:вырасти{}, // Официальный курс доллара вырос на 26 копеек.
rus_verbs:оглядываться{}, // оглядываться на девушек
rus_verbs:расходиться{}, // расходиться на отдых
rus_verbs:поскакать{}, // поскакать на службу
rus_verbs:прыгать{}, // прыгать на сцену
rus_verbs:приглашать{}, // приглашать на обед
rus_verbs:рваться{}, // Кусок ткани рвется на части
rus_verbs:понестись{}, // понестись на волю
rus_verbs:распространяться{}, // распространяться на всех жителей штата
инфинитив:просыпаться{ вид:соверш }, глагол:просыпаться{ вид:соверш }, // просыпаться на пол
инфинитив:просыпаться{ вид:несоверш }, глагол:просыпаться{ вид:несоверш },
деепричастие:просыпавшись{}, деепричастие:просыпаясь{},
rus_verbs:заехать{}, // заехать на пандус
rus_verbs:разобрать{}, // разобрать на составляющие
rus_verbs:опускаться{}, // опускаться на колени
rus_verbs:переехать{}, // переехать на конспиративную квартиру
rus_verbs:закрывать{}, // закрывать глаза на действия конкурентов
rus_verbs:поместить{}, // поместить на поднос
rus_verbs:отходить{}, // отходить на подготовленные позиции
rus_verbs:сыпаться{}, // сыпаться на плечи
rus_verbs:отвезти{}, // отвезти на занятия
rus_verbs:накинуть{}, // накинуть на плечи
rus_verbs:отлететь{}, // отлететь на пол
rus_verbs:закинуть{}, // закинуть на чердак
rus_verbs:зашипеть{}, // зашипеть на собаку
rus_verbs:прогреметь{}, // прогреметь на всю страну
rus_verbs:повалить{}, // повалить на стол
rus_verbs:опереть{}, // опереть на фундамент
rus_verbs:забросить{}, // забросить на антресоль
rus_verbs:подействовать{}, // подействовать на материал
rus_verbs:разделять{}, // разделять на части
rus_verbs:прикрикнуть{}, // прикрикнуть на детей
rus_verbs:разложить{}, // разложить на множители
rus_verbs:провожать{}, // провожать на работу
rus_verbs:катить{}, // катить на стройку
rus_verbs:наложить{}, // наложить запрет на проведение операций с недвижимостью
rus_verbs:сохранять{}, // сохранять на память
rus_verbs:злиться{}, // злиться на друга
rus_verbs:оборачиваться{}, // оборачиваться на свист
rus_verbs:сползти{}, // сползти на землю
rus_verbs:записывать{}, // записывать на ленту
rus_verbs:загнать{}, // загнать на дерево
rus_verbs:забормотать{}, // забормотать на ухо
rus_verbs:протиснуться{}, // протиснуться на самый край
rus_verbs:заторопиться{}, // заторопиться на вручение премии
rus_verbs:гаркнуть{}, // гаркнуть на шалунов
rus_verbs:навалиться{}, // навалиться на виновника всей толпой
rus_verbs:проскользнуть{}, // проскользнуть на крышу дома
rus_verbs:подтянуть{}, // подтянуть на палубу
rus_verbs:скатиться{}, // скатиться на двойки
rus_verbs:давить{}, // давить на жалость
rus_verbs:намекнуть{}, // намекнуть на новые обстоятельства
rus_verbs:замахнуться{}, // замахнуться на святое
rus_verbs:заменить{}, // заменить на свежую салфетку
rus_verbs:свалить{}, // свалить на землю
rus_verbs:стекать{}, // стекать на оголенные провода
rus_verbs:увеличиваться{}, // увеличиваться на сотню процентов
rus_verbs:развалиться{}, // развалиться на части
rus_verbs:сердиться{}, // сердиться на товарища
rus_verbs:обронить{}, // обронить на пол
rus_verbs:подсесть{}, // подсесть на наркоту
rus_verbs:реагировать{}, // реагировать на импульсы
rus_verbs:отпускать{}, // отпускать на волю
rus_verbs:прогнать{}, // прогнать на рабочее место
rus_verbs:ложить{}, // ложить на стол
rus_verbs:рвать{}, // рвать на части
rus_verbs:разлететься{}, // разлететься на кусочки
rus_verbs:превышать{}, // превышать на существенную величину
rus_verbs:сбиться{}, // сбиться на рысь
rus_verbs:пристроиться{}, // пристроиться на хорошую работу
rus_verbs:удрать{}, // удрать на пастбище
rus_verbs:толкать{}, // толкать на преступление
rus_verbs:посматривать{}, // посматривать на экран
rus_verbs:набирать{}, // набирать на судно
rus_verbs:отступать{}, // отступать на дерево
rus_verbs:подуть{}, // подуть на молоко
rus_verbs:плеснуть{}, // плеснуть на голову
rus_verbs:соскользнуть{}, // соскользнуть на землю
rus_verbs:затаить{}, // затаить на кого-то обиду
rus_verbs:обижаться{}, // обижаться на Колю
rus_verbs:смахнуть{}, // смахнуть на пол
rus_verbs:застегнуть{}, // застегнуть на все пуговицы
rus_verbs:спускать{}, // спускать на землю
rus_verbs:греметь{}, // греметь на всю округу
rus_verbs:скосить{}, // скосить на соседа глаз
rus_verbs:отважиться{}, // отважиться на прыжок
rus_verbs:литься{}, // литься на землю
rus_verbs:порвать{}, // порвать на тряпки
rus_verbs:проследовать{}, // проследовать на сцену
rus_verbs:надевать{}, // надевать на голову
rus_verbs:проскочить{}, // проскочить на красный свет
rus_verbs:прилечь{}, // прилечь на диванчик
rus_verbs:разделиться{}, // разделиться на небольшие группы
rus_verbs:завыть{}, // завыть на луну
rus_verbs:переносить{}, // переносить на другую машину
rus_verbs:наговорить{}, // наговорить на сотню рублей
rus_verbs:намекать{}, // намекать на новые обстоятельства
rus_verbs:нападать{}, // нападать на охранников
rus_verbs:убегать{}, // убегать на другое место
rus_verbs:тратить{}, // тратить на развлечения
rus_verbs:присаживаться{}, // присаживаться на корточки
rus_verbs:переместиться{}, // переместиться на вторую линию
rus_verbs:завалиться{}, // завалиться на диван
rus_verbs:удалиться{}, // удалиться на покой
rus_verbs:уменьшаться{}, // уменьшаться на несколько процентов
rus_verbs:обрушить{}, // обрушить на голову
rus_verbs:резать{}, // резать на части
rus_verbs:умчаться{}, // умчаться на юг
rus_verbs:навернуться{}, // навернуться на камень
rus_verbs:примчаться{}, // примчаться на матч
rus_verbs:издавать{}, // издавать на собственные средства
rus_verbs:переключить{}, // переключить на другой язык
rus_verbs:отправлять{}, // отправлять на пенсию
rus_verbs:залечь{}, // залечь на дно
rus_verbs:установиться{}, // установиться на диск
rus_verbs:направлять{}, // направлять на дополнительное обследование
rus_verbs:разрезать{}, // разрезать на части
rus_verbs:оскалиться{}, // оскалиться на прохожего
rus_verbs:рычать{}, // рычать на пьяных
rus_verbs:погружаться{}, // погружаться на дно
rus_verbs:опираться{}, // опираться на костыли
rus_verbs:поторопиться{}, // поторопиться на учебу
rus_verbs:сдвинуться{}, // сдвинуться на сантиметр
rus_verbs:увеличить{}, // увеличить на процент
rus_verbs:опускать{}, // опускать на землю
rus_verbs:созвать{}, // созвать на митинг
rus_verbs:делить{}, // делить на части
rus_verbs:пробиться{}, // пробиться на заключительную часть
rus_verbs:простираться{}, // простираться на много миль
rus_verbs:забить{}, // забить на учебу
rus_verbs:переложить{}, // переложить на чужие плечи
rus_verbs:грохнуться{}, // грохнуться на землю
rus_verbs:прорваться{}, // прорваться на сцену
rus_verbs:разлить{}, // разлить на землю
rus_verbs:укладываться{}, // укладываться на ночевку
rus_verbs:уволить{}, // уволить на пенсию
rus_verbs:наносить{}, // наносить на кожу
rus_verbs:набежать{}, // набежать на берег
rus_verbs:заявиться{}, // заявиться на стрельбище
rus_verbs:налиться{}, // налиться на крышку
rus_verbs:надвигаться{}, // надвигаться на берег
rus_verbs:распустить{}, // распустить на каникулы
rus_verbs:переключиться{}, // переключиться на другую задачу
rus_verbs:чихнуть{}, // чихнуть на окружающих
rus_verbs:шлепнуться{}, // шлепнуться на спину
rus_verbs:устанавливать{}, // устанавливать на крышу
rus_verbs:устанавливаться{}, // устанавливаться на крышу
rus_verbs:устраиваться{}, // устраиваться на работу
rus_verbs:пропускать{}, // пропускать на стадион
инфинитив:сбегать{ вид:соверш }, глагол:сбегать{ вид:соверш }, // сбегать на фильм
инфинитив:сбегать{ вид:несоверш }, глагол:сбегать{ вид:несоверш },
деепричастие:сбегав{}, деепричастие:сбегая{},
rus_verbs:показываться{}, // показываться на глаза
rus_verbs:прибегать{}, // прибегать на урок
rus_verbs:съездить{}, // съездить на ферму
rus_verbs:прославиться{}, // прославиться на всю страну
rus_verbs:опрокинуться{}, // опрокинуться на спину
rus_verbs:насыпать{}, // насыпать на землю
rus_verbs:употреблять{}, // употреблять на корм скоту
rus_verbs:пристроить{}, // пристроить на работу
rus_verbs:заворчать{}, // заворчать на вошедшего
rus_verbs:завязаться{}, // завязаться на поставщиков
rus_verbs:сажать{}, // сажать на стул
rus_verbs:напрашиваться{}, // напрашиваться на жесткие ответные меры
rus_verbs:заменять{}, // заменять на исправную
rus_verbs:нацепить{}, // нацепить на голову
rus_verbs:сыпать{}, // сыпать на землю
rus_verbs:закрываться{}, // закрываться на ремонт
rus_verbs:распространиться{}, // распространиться на всю популяцию
rus_verbs:поменять{}, // поменять на велосипед
rus_verbs:пересесть{}, // пересесть на велосипеды
rus_verbs:подоспеть{}, // подоспеть на разбор
rus_verbs:шипеть{}, // шипеть на собак
rus_verbs:поделить{}, // поделить на части
rus_verbs:подлететь{}, // подлететь на расстояние выстрела
rus_verbs:нажимать{}, // нажимать на все кнопки
rus_verbs:распасться{}, // распасться на части
rus_verbs:приволочь{}, // приволочь на диван
rus_verbs:пожить{}, // пожить на один доллар
rus_verbs:устремляться{}, // устремляться на свободу
rus_verbs:смахивать{}, // смахивать на пол
rus_verbs:забежать{}, // забежать на обед
rus_verbs:увеличиться{}, // увеличиться на существенную величину
rus_verbs:прокрасться{}, // прокрасться на склад
rus_verbs:пущать{}, // пущать на постой
rus_verbs:отклонить{}, // отклонить на несколько градусов
rus_verbs:насмотреться{}, // насмотреться на безобразия
rus_verbs:настроить{}, // настроить на короткие волны
rus_verbs:уменьшиться{}, // уменьшиться на пару сантиметров
rus_verbs:поменяться{}, // поменяться на другую книжку
rus_verbs:расколоться{}, // расколоться на части
rus_verbs:разлиться{}, // разлиться на землю
rus_verbs:срываться{}, // срываться на жену
rus_verbs:осудить{}, // осудить на пожизненное заключение
rus_verbs:передвинуть{}, // передвинуть на первое место
rus_verbs:допускаться{}, // допускаться на полигон
rus_verbs:задвинуть{}, // задвинуть на полку
rus_verbs:повлиять{}, // повлиять на оценку
rus_verbs:отбавлять{}, // отбавлять на осмотр
rus_verbs:сбрасывать{}, // сбрасывать на землю
rus_verbs:накинуться{}, // накинуться на случайных прохожих
rus_verbs:пролить{}, // пролить на кожу руки
rus_verbs:затащить{}, // затащить на сеновал
rus_verbs:перебежать{}, // перебежать на сторону противника
rus_verbs:наливать{}, // наливать на скатерть
rus_verbs:пролезть{}, // пролезть на сцену
rus_verbs:откладывать{}, // откладывать на черный день
rus_verbs:распадаться{}, // распадаться на небольшие фрагменты
rus_verbs:перечислить{}, // перечислить на счет
rus_verbs:закачаться{}, // закачаться на верхний уровень
rus_verbs:накрениться{}, // накрениться на правый борт
rus_verbs:подвинуться{}, // подвинуться на один уровень
rus_verbs:разнести{}, // разнести на мелкие кусочки
rus_verbs:зажить{}, // зажить на широкую ногу
rus_verbs:оглохнуть{}, // оглохнуть на правое ухо
rus_verbs:посетовать{}, // посетовать на бюрократизм
rus_verbs:уводить{}, // уводить на осмотр
rus_verbs:ускакать{}, // ускакать на забег
rus_verbs:посветить{}, // посветить на стену
rus_verbs:разрываться{}, // разрываться на части
rus_verbs:побросать{}, // побросать на землю
rus_verbs:карабкаться{}, // карабкаться на скалу
rus_verbs:нахлынуть{}, // нахлынуть на кого-то
rus_verbs:разлетаться{}, // разлетаться на мелкие осколочки
rus_verbs:среагировать{}, // среагировать на сигнал
rus_verbs:претендовать{}, // претендовать на приз
rus_verbs:дунуть{}, // дунуть на одуванчик
rus_verbs:переводиться{}, // переводиться на другую работу
rus_verbs:перевезти{}, // перевезти на другую площадку
rus_verbs:топать{}, // топать на урок
rus_verbs:относить{}, // относить на склад
rus_verbs:сбивать{}, // сбивать на землю
rus_verbs:укладывать{}, // укладывать на спину
rus_verbs:укатить{}, // укатить на отдых
rus_verbs:убирать{}, // убирать на полку
rus_verbs:опасть{}, // опасть на землю
rus_verbs:ронять{}, // ронять на снег
rus_verbs:пялиться{}, // пялиться на тело
rus_verbs:глазеть{}, // глазеть на тело
rus_verbs:снижаться{}, // снижаться на безопасную высоту
rus_verbs:запрыгнуть{}, // запрыгнуть на платформу
rus_verbs:разбиваться{}, // разбиваться на главы
rus_verbs:сгодиться{}, // сгодиться на фарш
rus_verbs:перескочить{}, // перескочить на другую страницу
rus_verbs:нацелиться{}, // нацелиться на главную добычу
rus_verbs:заезжать{}, // заезжать на бордюр
rus_verbs:забираться{}, // забираться на крышу
rus_verbs:проорать{}, // проорать на всё село
rus_verbs:сбежаться{}, // сбежаться на шум
rus_verbs:сменять{}, // сменять на хлеб
rus_verbs:мотать{}, // мотать на ус
rus_verbs:раскалываться{}, // раскалываться на две половинки
rus_verbs:коситься{}, // коситься на режиссёра
rus_verbs:плевать{}, // плевать на законы
rus_verbs:ссылаться{}, // ссылаться на авторитетное мнение
rus_verbs:наставить{}, // наставить на путь истинный
rus_verbs:завывать{}, // завывать на Луну
rus_verbs:опаздывать{}, // опаздывать на совещание
rus_verbs:залюбоваться{}, // залюбоваться на пейзаж
rus_verbs:повергнуть{}, // повергнуть на землю
rus_verbs:надвинуть{}, // надвинуть на лоб
rus_verbs:стекаться{}, // стекаться на площадь
rus_verbs:обозлиться{}, // обозлиться на тренера
rus_verbs:оттянуть{}, // оттянуть на себя
rus_verbs:истратить{}, // истратить на дешевых шлюх
rus_verbs:вышвырнуть{}, // вышвырнуть на улицу
rus_verbs:затолкать{}, // затолкать на верхнюю полку
rus_verbs:заскочить{}, // заскочить на огонек
rus_verbs:проситься{}, // проситься на улицу
rus_verbs:натыкаться{}, // натыкаться на борщевик
rus_verbs:обрушиваться{}, // обрушиваться на митингующих
rus_verbs:переписать{}, // переписать на чистовик
rus_verbs:переноситься{}, // переноситься на другое устройство
rus_verbs:напроситься{}, // напроситься на обидный ответ
rus_verbs:натягивать{}, // натягивать на ноги
rus_verbs:кидаться{}, // кидаться на прохожих
rus_verbs:откликаться{}, // откликаться на призыв
rus_verbs:поспевать{}, // поспевать на балет
rus_verbs:обратиться{}, // обратиться на кафедру
rus_verbs:полюбоваться{}, // полюбоваться на бюст
rus_verbs:таращиться{}, // таращиться на мустангов
rus_verbs:напороться{}, // напороться на колючки
rus_verbs:раздать{}, // раздать на руки
rus_verbs:дивиться{}, // дивиться на танцовщиц
rus_verbs:назначать{}, // назначать на ответственнейший пост
rus_verbs:кидать{}, // кидать на балкон
rus_verbs:нахлобучить{}, // нахлобучить на башку
rus_verbs:увлекать{}, // увлекать на луг
rus_verbs:ругнуться{}, // ругнуться на животину
rus_verbs:переселиться{}, // переселиться на хутор
rus_verbs:разрывать{}, // разрывать на части
rus_verbs:утащить{}, // утащить на дерево
rus_verbs:наставлять{}, // наставлять на путь
rus_verbs:соблазнить{}, // соблазнить на обмен
rus_verbs:накладывать{}, // накладывать на рану
rus_verbs:набрести{}, // набрести на грибную поляну
rus_verbs:наведываться{}, // наведываться на прежнюю работу
rus_verbs:погулять{}, // погулять на чужие деньги
rus_verbs:уклоняться{}, // уклоняться на два градуса влево
rus_verbs:слезать{}, // слезать на землю
rus_verbs:клевать{}, // клевать на мотыля
// rus_verbs:назначаться{}, // назначаться на пост
rus_verbs:напялить{}, // напялить на голову
rus_verbs:натянуться{}, // натянуться на рамку
rus_verbs:разгневаться{}, // разгневаться на придворных
rus_verbs:эмигрировать{}, // эмигрировать на Кипр
rus_verbs:накатить{}, // накатить на основу
rus_verbs:пригнать{}, // пригнать на пастбище
rus_verbs:обречь{}, // обречь на мучения
rus_verbs:сокращаться{}, // сокращаться на четверть
rus_verbs:оттеснить{}, // оттеснить на пристань
rus_verbs:подбить{}, // подбить на аферу
rus_verbs:заманить{}, // заманить на дерево
инфинитив:пописать{ aux stress="поп^исать" }, глагол:пописать{ aux stress="поп^исать" }, // пописать на кустик
// деепричастие:пописав{ aux stress="поп^исать" },
rus_verbs:посходить{}, // посходить на перрон
rus_verbs:налечь{}, // налечь на мясцо
rus_verbs:отбирать{}, // отбирать на флот
rus_verbs:нашептывать{}, // нашептывать на ухо
rus_verbs:откладываться{}, // откладываться на будущее
rus_verbs:залаять{}, // залаять на грабителя
rus_verbs:настроиться{}, // настроиться на прием
rus_verbs:разбивать{}, // разбивать на куски
rus_verbs:пролиться{}, // пролиться на почву
rus_verbs:сетовать{}, // сетовать на объективные трудности
rus_verbs:подвезти{}, // подвезти на митинг
rus_verbs:припереться{}, // припереться на праздник
rus_verbs:подталкивать{}, // подталкивать на прыжок
rus_verbs:прорываться{}, // прорываться на сцену
rus_verbs:снижать{}, // снижать на несколько процентов
rus_verbs:нацелить{}, // нацелить на танк
rus_verbs:расколоть{}, // расколоть на два куска
rus_verbs:увозить{}, // увозить на обкатку
rus_verbs:оседать{}, // оседать на дно
rus_verbs:съедать{}, // съедать на ужин
rus_verbs:навлечь{}, // навлечь на себя
rus_verbs:равняться{}, // равняться на лучших
rus_verbs:сориентироваться{}, // сориентироваться на местности
rus_verbs:снизить{}, // снизить на несколько процентов
rus_verbs:перенестись{}, // перенестись на много лет назад
rus_verbs:завезти{}, // завезти на склад
rus_verbs:проложить{}, // проложить на гору
rus_verbs:понадеяться{}, // понадеяться на удачу
rus_verbs:заступить{}, // заступить на вахту
rus_verbs:засеменить{}, // засеменить на выход
rus_verbs:запирать{}, // запирать на ключ
rus_verbs:скатываться{}, // скатываться на землю
rus_verbs:дробить{}, // дробить на части
rus_verbs:разваливаться{}, // разваливаться на кусочки
rus_verbs:завозиться{}, // завозиться на склад
rus_verbs:нанимать{}, // нанимать на дневную работу
rus_verbs:поспеть{}, // поспеть на концерт
rus_verbs:променять{}, // променять на сытость
rus_verbs:переправить{}, // переправить на север
rus_verbs:налетать{}, // налетать на силовое поле
rus_verbs:затворить{}, // затворить на замок
rus_verbs:подогнать{}, // подогнать на пристань
rus_verbs:наехать{}, // наехать на камень
rus_verbs:распевать{}, // распевать на разные голоса
rus_verbs:разносить{}, // разносить на клочки
rus_verbs:преувеличивать{}, // преувеличивать на много килограммов
rus_verbs:хромать{}, // хромать на одну ногу
rus_verbs:телеграфировать{}, // телеграфировать на базу
rus_verbs:порезать{}, // порезать на лоскуты
rus_verbs:порваться{}, // порваться на части
rus_verbs:загонять{}, // загонять на дерево
rus_verbs:отбывать{}, // отбывать на место службы
rus_verbs:усаживаться{}, // усаживаться на трон
rus_verbs:накопить{}, // накопить на квартиру
rus_verbs:зыркнуть{}, // зыркнуть на визитера
rus_verbs:копить{}, // копить на машину
rus_verbs:помещать{}, // помещать на верхнюю грань
rus_verbs:сползать{}, // сползать на снег
rus_verbs:попроситься{}, // попроситься на улицу
rus_verbs:перетащить{}, // перетащить на чердак
rus_verbs:растащить{}, // растащить на сувениры
rus_verbs:ниспадать{}, // ниспадать на землю
rus_verbs:сфотографировать{}, // сфотографировать на память
rus_verbs:нагонять{}, // нагонять на конкурентов страх
rus_verbs:покушаться{}, // покушаться на понтифика
rus_verbs:покуситься{},
rus_verbs:наняться{}, // наняться на службу
rus_verbs:просачиваться{}, // просачиваться на поверхность
rus_verbs:пускаться{}, // пускаться на ветер
rus_verbs:отваживаться{}, // отваживаться на прыжок
rus_verbs:досадовать{}, // досадовать на объективные трудности
rus_verbs:унестись{}, // унестись на небо
rus_verbs:ухудшаться{}, // ухудшаться на несколько процентов
rus_verbs:насадить{}, // насадить на копьё
rus_verbs:нагрянуть{}, // нагрянуть на праздник
rus_verbs:зашвырнуть{}, // зашвырнуть на полку
rus_verbs:грешить{}, // грешить на постояльцев
rus_verbs:просочиться{}, // просочиться на поверхность
rus_verbs:надоумить{}, // надоумить на глупость
rus_verbs:намотать{}, // намотать на шпиндель
rus_verbs:замкнуть{}, // замкнуть на корпус
rus_verbs:цыкнуть{}, // цыкнуть на детей
rus_verbs:переворачиваться{}, // переворачиваться на спину
rus_verbs:соваться{}, // соваться на площать
rus_verbs:отлучиться{}, // отлучиться на обед
rus_verbs:пенять{}, // пенять на себя
rus_verbs:нарезать{}, // нарезать на ломтики
rus_verbs:поставлять{}, // поставлять на Кипр
rus_verbs:залезать{}, // залезать на балкон
rus_verbs:отлучаться{}, // отлучаться на обед
rus_verbs:сбиваться{}, // сбиваться на шаг
rus_verbs:таращить{}, // таращить глаза на вошедшего
rus_verbs:прошмыгнуть{}, // прошмыгнуть на кухню
rus_verbs:опережать{}, // опережать на пару сантиметров
rus_verbs:переставить{}, // переставить на стол
rus_verbs:раздирать{}, // раздирать на части
rus_verbs:затвориться{}, // затвориться на засовы
rus_verbs:материться{}, // материться на кого-то
rus_verbs:наскочить{}, // наскочить на риф
rus_verbs:набираться{}, // набираться на борт
rus_verbs:покрикивать{}, // покрикивать на помощников
rus_verbs:заменяться{}, // заменяться на более новый
rus_verbs:подсадить{}, // подсадить на верхнюю полку
rus_verbs:проковылять{}, // проковылять на кухню
rus_verbs:прикатить{}, // прикатить на старт
rus_verbs:залететь{}, // залететь на чужую территорию
rus_verbs:загрузить{}, // загрузить на конвейер
rus_verbs:уплывать{}, // уплывать на материк
rus_verbs:опозорить{}, // опозорить на всю деревню
rus_verbs:провоцировать{}, // провоцировать на ответную агрессию
rus_verbs:забивать{}, // забивать на учебу
rus_verbs:набегать{}, // набегать на прибрежные деревни
rus_verbs:запираться{}, // запираться на ключ
rus_verbs:фотографировать{}, // фотографировать на мыльницу
rus_verbs:подымать{}, // подымать на недосягаемую высоту
rus_verbs:съезжаться{}, // съезжаться на симпозиум
rus_verbs:отвлекаться{}, // отвлекаться на игру
rus_verbs:проливать{}, // проливать на брюки
rus_verbs:спикировать{}, // спикировать на зазевавшегося зайца
rus_verbs:уползти{}, // уползти на вершину холма
rus_verbs:переместить{}, // переместить на вторую палубу
rus_verbs:превысить{}, // превысить на несколько метров
rus_verbs:передвинуться{}, // передвинуться на соседнюю клетку
rus_verbs:спровоцировать{}, // спровоцировать на бросок
rus_verbs:сместиться{}, // сместиться на соседнюю клетку
rus_verbs:заготовить{}, // заготовить на зиму
rus_verbs:плеваться{}, // плеваться на пол
rus_verbs:переселить{}, // переселить на север
rus_verbs:напирать{}, // напирать на дверь
rus_verbs:переезжать{}, // переезжать на другой этаж
rus_verbs:приподнимать{}, // приподнимать на несколько сантиметров
rus_verbs:трогаться{}, // трогаться на красный свет
rus_verbs:надвинуться{}, // надвинуться на глаза
rus_verbs:засмотреться{}, // засмотреться на купальники
rus_verbs:убыть{}, // убыть на фронт
rus_verbs:передвигать{}, // передвигать на второй уровень
rus_verbs:отвозить{}, // отвозить на свалку
rus_verbs:обрекать{}, // обрекать на гибель
rus_verbs:записываться{}, // записываться на танцы
rus_verbs:настраивать{}, // настраивать на другой диапазон
rus_verbs:переписывать{}, // переписывать на диск
rus_verbs:израсходовать{}, // израсходовать на гонки
rus_verbs:обменять{}, // обменять на перспективного игрока
rus_verbs:трубить{}, // трубить на всю округу
rus_verbs:набрасываться{}, // набрасываться на жертву
rus_verbs:чихать{}, // чихать на правила
rus_verbs:наваливаться{}, // наваливаться на рычаг
rus_verbs:сподобиться{}, // сподобиться на повторный анализ
rus_verbs:намазать{}, // намазать на хлеб
rus_verbs:прореагировать{}, // прореагировать на вызов
rus_verbs:зачислить{}, // зачислить на факультет
rus_verbs:наведаться{}, // наведаться на склад
rus_verbs:откидываться{}, // откидываться на спинку кресла
rus_verbs:захромать{}, // захромать на левую ногу
rus_verbs:перекочевать{}, // перекочевать на другой берег
rus_verbs:накатываться{}, // накатываться на песчаный берег
rus_verbs:приостановить{}, // приостановить на некоторое время
rus_verbs:запрятать{}, // запрятать на верхнюю полочку
rus_verbs:прихрамывать{}, // прихрамывать на правую ногу
rus_verbs:упорхнуть{}, // упорхнуть на свободу
rus_verbs:расстегивать{}, // расстегивать на пальто
rus_verbs:напуститься{}, // напуститься на бродягу
rus_verbs:накатывать{}, // накатывать на оригинал
rus_verbs:наезжать{}, // наезжать на простофилю
rus_verbs:тявкнуть{}, // тявкнуть на подошедшего человека
rus_verbs:отрядить{}, // отрядить на починку
rus_verbs:положиться{}, // положиться на главаря
rus_verbs:опрокидывать{}, // опрокидывать на голову
rus_verbs:поторапливаться{}, // поторапливаться на рейс
rus_verbs:налагать{}, // налагать на заемщика
rus_verbs:скопировать{}, // скопировать на диск
rus_verbs:опадать{}, // опадать на землю
rus_verbs:купиться{}, // купиться на посулы
rus_verbs:гневаться{}, // гневаться на слуг
rus_verbs:слететься{}, // слететься на раздачу
rus_verbs:убавить{}, // убавить на два уровня
rus_verbs:спихнуть{}, // спихнуть на соседа
rus_verbs:накричать{}, // накричать на ребенка
rus_verbs:приберечь{}, // приберечь на ужин
rus_verbs:приклеить{}, // приклеить на ветровое стекло
rus_verbs:ополчиться{}, // ополчиться на посредников
rus_verbs:тратиться{}, // тратиться на сувениры
rus_verbs:слетаться{}, // слетаться на свет
rus_verbs:доставляться{}, // доставляться на базу
rus_verbs:поплевать{}, // поплевать на руки
rus_verbs:огрызаться{}, // огрызаться на замечание
rus_verbs:попереться{}, // попереться на рынок
rus_verbs:растягиваться{}, // растягиваться на полу
rus_verbs:повергать{}, // повергать на землю
rus_verbs:ловиться{}, // ловиться на мотыля
rus_verbs:наседать{}, // наседать на обороняющихся
rus_verbs:развалить{}, // развалить на кирпичи
rus_verbs:разломить{}, // разломить на несколько частей
rus_verbs:примерить{}, // примерить на себя
rus_verbs:лепиться{}, // лепиться на стену
rus_verbs:скопить{}, // скопить на старость
rus_verbs:затратить{}, // затратить на ликвидацию последствий
rus_verbs:притащиться{}, // притащиться на гулянку
rus_verbs:осерчать{}, // осерчать на прислугу
rus_verbs:натравить{}, // натравить на медведя
rus_verbs:ссыпать{}, // ссыпать на землю
rus_verbs:подвозить{}, // подвозить на пристань
rus_verbs:мобилизовать{}, // мобилизовать на сборы
rus_verbs:смотаться{}, // смотаться на работу
rus_verbs:заглядеться{}, // заглядеться на девчонок
rus_verbs:таскаться{}, // таскаться на работу
rus_verbs:разгружать{}, // разгружать на транспортер
rus_verbs:потреблять{}, // потреблять на кондиционирование
инфинитив:сгонять{ вид:соверш }, глагол:сгонять{ вид:соверш }, // сгонять на базу
деепричастие:сгоняв{},
rus_verbs:посылаться{}, // посылаться на разведку
rus_verbs:окрыситься{}, // окрыситься на кого-то
rus_verbs:отлить{}, // отлить на сковороду
rus_verbs:шикнуть{}, // шикнуть на детишек
rus_verbs:уповать{}, // уповать на бескорысную помощь
rus_verbs:класться{}, // класться на стол
rus_verbs:поковылять{}, // поковылять на выход
rus_verbs:навевать{}, // навевать на собравшихся скуку
rus_verbs:накладываться{}, // накладываться на грунтовку
rus_verbs:наноситься{}, // наноситься на чистую кожу
// rus_verbs:запланировать{}, // запланировать на среду
rus_verbs:кувыркнуться{}, // кувыркнуться на землю
rus_verbs:гавкнуть{}, // гавкнуть на хозяина
rus_verbs:перестроиться{}, // перестроиться на новый лад
rus_verbs:расходоваться{}, // расходоваться на образование
rus_verbs:дуться{}, // дуться на бабушку
rus_verbs:перетаскивать{}, // перетаскивать на рабочий стол
rus_verbs:издаться{}, // издаться на деньги спонсоров
rus_verbs:смещаться{}, // смещаться на несколько миллиметров
rus_verbs:зазывать{}, // зазывать на новогоднюю распродажу
rus_verbs:пикировать{}, // пикировать на окопы
rus_verbs:чертыхаться{}, // чертыхаться на мешающихся детей
rus_verbs:зудить{}, // зудить на ухо
rus_verbs:подразделяться{}, // подразделяться на группы
rus_verbs:изливаться{}, // изливаться на землю
rus_verbs:помочиться{}, // помочиться на траву
rus_verbs:примерять{}, // примерять на себя
rus_verbs:разрядиться{}, // разрядиться на землю
rus_verbs:мотнуться{}, // мотнуться на крышу
rus_verbs:налегать{}, // налегать на весла
rus_verbs:зацокать{}, // зацокать на куриц
rus_verbs:наниматься{}, // наниматься на корабль
rus_verbs:сплевывать{}, // сплевывать на землю
rus_verbs:настучать{}, // настучать на саботажника
rus_verbs:приземляться{}, // приземляться на брюхо
rus_verbs:наталкиваться{}, // наталкиваться на объективные трудности
rus_verbs:посигналить{}, // посигналить нарушителю, выехавшему на встречную полосу
rus_verbs:серчать{}, // серчать на нерасторопную помощницу
rus_verbs:сваливать{}, // сваливать на подоконник
rus_verbs:засобираться{}, // засобираться на работу
rus_verbs:распилить{}, // распилить на одинаковые бруски
//rus_verbs:умножать{}, // умножать на константу
rus_verbs:копировать{}, // копировать на диск
rus_verbs:накрутить{}, // накрутить на руку
rus_verbs:навалить{}, // навалить на телегу
rus_verbs:натолкнуть{}, // натолкнуть на свежую мысль
rus_verbs:шлепаться{}, // шлепаться на бетон
rus_verbs:ухлопать{}, // ухлопать на скупку произведений искусства
rus_verbs:замахиваться{}, // замахиваться на авторитетнейшее мнение
rus_verbs:посягнуть{}, // посягнуть на святое
rus_verbs:разменять{}, // разменять на мелочь
rus_verbs:откатываться{}, // откатываться на заранее подготовленные позиции
rus_verbs:усаживать{}, // усаживать на скамейку
rus_verbs:натаскать{}, // натаскать на поиск наркотиков
rus_verbs:зашикать{}, // зашикать на кошку
rus_verbs:разломать{}, // разломать на равные части
rus_verbs:приглашаться{}, // приглашаться на сцену
rus_verbs:присягать{}, // присягать на верность
rus_verbs:запрограммировать{}, // запрограммировать на постоянную уборку
rus_verbs:расщедриться{}, // расщедриться на новый компьютер
rus_verbs:насесть{}, // насесть на двоечников
rus_verbs:созывать{}, // созывать на собрание
rus_verbs:позариться{}, // позариться на чужое добро
rus_verbs:перекидываться{}, // перекидываться на соседние здания
rus_verbs:наползать{}, // наползать на неповрежденную ткань
rus_verbs:изрубить{}, // изрубить на мелкие кусочки
rus_verbs:наворачиваться{}, // наворачиваться на глаза
rus_verbs:раскричаться{}, // раскричаться на всю округу
rus_verbs:переползти{}, // переползти на светлую сторону
rus_verbs:уполномочить{}, // уполномочить на разведовательную операцию
rus_verbs:мочиться{}, // мочиться на трупы убитых врагов
rus_verbs:радировать{}, // радировать на базу
rus_verbs:промотать{}, // промотать на начало
rus_verbs:заснять{}, // заснять на видео
rus_verbs:подбивать{}, // подбивать на матч-реванш
rus_verbs:наплевать{}, // наплевать на справедливость
rus_verbs:подвывать{}, // подвывать на луну
rus_verbs:расплескать{}, // расплескать на пол
rus_verbs:польститься{}, // польститься на бесплатный сыр
rus_verbs:помчать{}, // помчать на работу
rus_verbs:съезжать{}, // съезжать на обочину
rus_verbs:нашептать{}, // нашептать кому-то на ухо
rus_verbs:наклеить{}, // наклеить на доску объявлений
rus_verbs:завозить{}, // завозить на склад
rus_verbs:заявляться{}, // заявляться на любимую работу
rus_verbs:наглядеться{}, // наглядеться на воробьев
rus_verbs:хлопнуться{}, // хлопнуться на живот
rus_verbs:забредать{}, // забредать на поляну
rus_verbs:посягать{}, // посягать на исконные права собственности
rus_verbs:сдвигать{}, // сдвигать на одну позицию
rus_verbs:спрыгивать{}, // спрыгивать на землю
rus_verbs:сдвигаться{}, // сдвигаться на две позиции
rus_verbs:разделать{}, // разделать на орехи
rus_verbs:разлагать{}, // разлагать на элементарные элементы
rus_verbs:обрушивать{}, // обрушивать на головы врагов
rus_verbs:натечь{}, // натечь на пол
rus_verbs:политься{}, // вода польется на землю
rus_verbs:успеть{}, // Они успеют на поезд.
инфинитив:мигрировать{ вид:несоверш }, глагол:мигрировать{ вид:несоверш },
деепричастие:мигрируя{},
инфинитив:мигрировать{ вид:соверш }, глагол:мигрировать{ вид:соверш },
деепричастие:мигрировав{},
rus_verbs:двинуться{}, // Мы скоро двинемся на дачу.
rus_verbs:подойти{}, // Он не подойдёт на должность секретаря.
rus_verbs:потянуть{}, // Он не потянет на директора.
rus_verbs:тянуть{}, // Он не тянет на директора.
rus_verbs:перескакивать{}, // перескакивать с одного примера на другой
rus_verbs:жаловаться{}, // Он жалуется на нездоровье.
rus_verbs:издать{}, // издать на деньги спонсоров
rus_verbs:показаться{}, // показаться на глаза
rus_verbs:высаживать{}, // высаживать на необитаемый остров
rus_verbs:вознестись{}, // вознестись на самую вершину славы
rus_verbs:залить{}, // залить на youtube
rus_verbs:закачать{}, // закачать на youtube
rus_verbs:сыграть{}, // сыграть на деньги
rus_verbs:экстраполировать{}, // Формулу можно экстраполировать на случай нескольких переменных
инфинитив:экстраполироваться{ вид:несоверш}, // Ситуация легко экстраполируется на случай нескольких переменных
глагол:экстраполироваться{ вид:несоверш},
инфинитив:экстраполироваться{ вид:соверш},
глагол:экстраполироваться{ вид:соверш},
деепричастие:экстраполируясь{},
инфинитив:акцентировать{вид:соверш}, // оратор акцентировал внимание слушателей на новый аспект проблемы
глагол:акцентировать{вид:соверш},
инфинитив:акцентировать{вид:несоверш},
глагол:акцентировать{вид:несоверш},
прилагательное:акцентировавший{вид:несоверш},
//прилагательное:акцентировавший{вид:соверш},
прилагательное:акцентирующий{},
деепричастие:акцентировав{},
деепричастие:акцентируя{},
rus_verbs:бабахаться{}, // он бабахался на пол
rus_verbs:бабахнуться{}, // мальчил бабахнулся на асфальт
rus_verbs:батрачить{}, // Крестьяне батрачили на хозяина
rus_verbs:бахаться{}, // Наездники бахались на землю
rus_verbs:бахнуться{}, // Наездник опять бахнулся на землю
rus_verbs:благословить{}, // батюшка благословил отрока на подвиг
rus_verbs:благословлять{}, // батюшка благословляет отрока на подвиг
rus_verbs:блевануть{}, // Он блеванул на землю
rus_verbs:блевать{}, // Он блюет на землю
rus_verbs:бухнуться{}, // Наездник бухнулся на землю
rus_verbs:валить{}, // Ветер валил деревья на землю
rus_verbs:спилить{}, // Спиленное дерево валится на землю
rus_verbs:ввезти{}, // Предприятие ввезло товар на таможню
rus_verbs:вдохновить{}, // Фильм вдохновил мальчика на поход в лес
rus_verbs:вдохновиться{}, // Мальчик вдохновился на поход
rus_verbs:вдохновлять{}, // Фильм вдохновляет на поход в лес
rus_verbs:вестись{}, // Не ведись на эти уловки!
rus_verbs:вешать{}, // Гости вешают одежду на вешалку
rus_verbs:вешаться{}, // Одежда вешается на вешалки
rus_verbs:вещать{}, // радиостанция вещает на всю страну
rus_verbs:взбираться{}, // Туристы взбираются на заросший лесом холм
rus_verbs:взбредать{}, // Что иногда взбредает на ум
rus_verbs:взбрести{}, // Что-то взбрело на ум
rus_verbs:взвалить{}, // Мама взвалила на свои плечи всё домашнее хозяйство
rus_verbs:взваливаться{}, // Все домашнее хозяйство взваливается на мамины плечи
rus_verbs:взваливать{}, // Не надо взваливать всё на мои плечи
rus_verbs:взглянуть{}, // Кошка взглянула на мышку
rus_verbs:взгромождать{}, // Мальчик взгромождает стул на стол
rus_verbs:взгромождаться{}, // Мальчик взгромождается на стол
rus_verbs:взгромоздить{}, // Мальчик взгромоздил стул на стол
rus_verbs:взгромоздиться{}, // Мальчик взгромоздился на стул
rus_verbs:взирать{}, // Очевидцы взирали на непонятный объект
rus_verbs:взлетать{}, // Фабрика фейерверков взлетает на воздух
rus_verbs:взлететь{}, // Фабрика фейерверков взлетела на воздух
rus_verbs:взобраться{}, // Туристы взобрались на гору
rus_verbs:взойти{}, // Туристы взошли на гору
rus_verbs:взъесться{}, // Отец взъелся на непутевого сына
rus_verbs:взъяриться{}, // Отец взъярился на непутевого сына
rus_verbs:вкатить{}, // рабочие вкатили бочку на пандус
rus_verbs:вкатывать{}, // рабочик вкатывают бочку на пандус
rus_verbs:влиять{}, // Это решение влияет на всех игроков рынка
rus_verbs:водворить{}, // водворить нарушителя на место
rus_verbs:водвориться{}, // водвориться на свое место
rus_verbs:водворять{}, // водворять вещь на свое место
rus_verbs:водворяться{}, // водворяться на свое место
rus_verbs:водружать{}, // водружать флаг на флагшток
rus_verbs:водружаться{}, // Флаг водружается на флагшток
rus_verbs:водрузить{}, // водрузить флаг на флагшток
rus_verbs:водрузиться{}, // Флаг водрузился на вершину горы
rus_verbs:воздействовать{}, // Излучение воздействует на кожу
rus_verbs:воззреть{}, // воззреть на поле боя
rus_verbs:воззриться{}, // воззриться на поле боя
rus_verbs:возить{}, // возить туристов на гору
rus_verbs:возлагать{}, // Многочисленные посетители возлагают цветы на могилу
rus_verbs:возлагаться{}, // Ответственность возлагается на начальство
rus_verbs:возлечь{}, // возлечь на лежанку
rus_verbs:возложить{}, // возложить цветы на могилу поэта
rus_verbs:вознести{}, // вознести кого-то на вершину славы
rus_verbs:возноситься{}, // возносится на вершину успеха
rus_verbs:возносить{}, // возносить счастливчика на вершину успеха
rus_verbs:подниматься{}, // Мы поднимаемся на восьмой этаж
rus_verbs:подняться{}, // Мы поднялись на восьмой этаж
rus_verbs:вонять{}, // Кусок сыра воняет на всю округу
rus_verbs:воодушевлять{}, // Идеалы воодушевляют на подвиги
rus_verbs:воодушевляться{}, // Люди воодушевляются на подвиги
rus_verbs:ворчать{}, // Старый пес ворчит на прохожих
rus_verbs:воспринимать{}, // воспринимать сообщение на слух
rus_verbs:восприниматься{}, // сообщение плохо воспринимается на слух
rus_verbs:воспринять{}, // воспринять сообщение на слух
rus_verbs:восприняться{}, // восприняться на слух
rus_verbs:воссесть{}, // Коля воссел на трон
rus_verbs:вправить{}, // вправить мозг на место
rus_verbs:вправлять{}, // вправлять мозги на место
rus_verbs:временить{}, // временить с выходом на пенсию
rus_verbs:врубать{}, // врубать на полную мощность
rus_verbs:врубить{}, // врубить на полную мощность
rus_verbs:врубиться{}, // врубиться на полную мощность
rus_verbs:врываться{}, // врываться на собрание
rus_verbs:вскарабкаться{}, // вскарабкаться на утёс
rus_verbs:вскарабкиваться{}, // вскарабкиваться на утёс
rus_verbs:вскочить{}, // вскочить на ноги
rus_verbs:всплывать{}, // всплывать на поверхность воды
rus_verbs:всплыть{}, // всплыть на поверхность воды
rus_verbs:вспрыгивать{}, // вспрыгивать на платформу
rus_verbs:вспрыгнуть{}, // вспрыгнуть на платформу
rus_verbs:встать{}, // встать на защиту чести и достоинства
rus_verbs:вторгаться{}, // вторгаться на чужую территорию
rus_verbs:вторгнуться{}, // вторгнуться на чужую территорию
rus_verbs:въезжать{}, // въезжать на пандус
rus_verbs:наябедничать{}, // наябедничать на соседа по парте
rus_verbs:выблевать{}, // выблевать завтрак на пол
rus_verbs:выблеваться{}, // выблеваться на пол
rus_verbs:выблевывать{}, // выблевывать завтрак на пол
rus_verbs:выблевываться{}, // выблевываться на пол
rus_verbs:вывезти{}, // вывезти мусор на свалку
rus_verbs:вывесить{}, // вывесить белье на просушку
rus_verbs:вывести{}, // вывести собаку на прогулку
rus_verbs:вывешивать{}, // вывешивать белье на веревку
rus_verbs:вывозить{}, // вывозить детей на природу
rus_verbs:вызывать{}, // Начальник вызывает на ковер
rus_verbs:выйти{}, // выйти на свободу
rus_verbs:выкладывать{}, // выкладывать на всеобщее обозрение
rus_verbs:выкладываться{}, // выкладываться на всеобщее обозрение
rus_verbs:выливать{}, // выливать на землю
rus_verbs:выливаться{}, // выливаться на землю
rus_verbs:вылить{}, // вылить жидкость на землю
rus_verbs:вылиться{}, // Топливо вылилось на землю
rus_verbs:выложить{}, // выложить на берег
rus_verbs:выменивать{}, // выменивать золото на хлеб
rus_verbs:вымениваться{}, // Золото выменивается на хлеб
rus_verbs:выменять{}, // выменять золото на хлеб
rus_verbs:выпадать{}, // снег выпадает на землю
rus_verbs:выплевывать{}, // выплевывать на землю
rus_verbs:выплевываться{}, // выплевываться на землю
rus_verbs:выплескать{}, // выплескать на землю
rus_verbs:выплескаться{}, // выплескаться на землю
rus_verbs:выплескивать{}, // выплескивать на землю
rus_verbs:выплескиваться{}, // выплескиваться на землю
rus_verbs:выплывать{}, // выплывать на поверхность
rus_verbs:выплыть{}, // выплыть на поверхность
rus_verbs:выплюнуть{}, // выплюнуть на пол
rus_verbs:выползать{}, // выползать на свежий воздух
rus_verbs:выпроситься{}, // выпроситься на улицу
rus_verbs:выпрыгивать{}, // выпрыгивать на свободу
rus_verbs:выпрыгнуть{}, // выпрыгнуть на перрон
rus_verbs:выпускать{}, // выпускать на свободу
rus_verbs:выпустить{}, // выпустить на свободу
rus_verbs:выпучивать{}, // выпучивать на кого-то глаза
rus_verbs:выпучиваться{}, // глаза выпучиваются на кого-то
rus_verbs:выпучить{}, // выпучить глаза на кого-то
rus_verbs:выпучиться{}, // выпучиться на кого-то
rus_verbs:выронить{}, // выронить на землю
rus_verbs:высадить{}, // высадить на берег
rus_verbs:высадиться{}, // высадиться на берег
rus_verbs:высаживаться{}, // высаживаться на остров
rus_verbs:выскальзывать{}, // выскальзывать на землю
rus_verbs:выскочить{}, // выскочить на сцену
rus_verbs:высморкаться{}, // высморкаться на землю
rus_verbs:высморкнуться{}, // высморкнуться на землю
rus_verbs:выставить{}, // выставить на всеобщее обозрение
rus_verbs:выставиться{}, // выставиться на всеобщее обозрение
rus_verbs:выставлять{}, // выставлять на всеобщее обозрение
rus_verbs:выставляться{}, // выставляться на всеобщее обозрение
инфинитив:высыпать{вид:соверш}, // высыпать на землю
инфинитив:высыпать{вид:несоверш},
глагол:высыпать{вид:соверш},
глагол:высыпать{вид:несоверш},
деепричастие:высыпав{},
деепричастие:высыпая{},
прилагательное:высыпавший{вид:соверш},
//++прилагательное:высыпавший{вид:несоверш},
прилагательное:высыпающий{вид:несоверш},
rus_verbs:высыпаться{}, // высыпаться на землю
rus_verbs:вытаращивать{}, // вытаращивать глаза на медведя
rus_verbs:вытаращиваться{}, // вытаращиваться на медведя
rus_verbs:вытаращить{}, // вытаращить глаза на медведя
rus_verbs:вытаращиться{}, // вытаращиться на медведя
rus_verbs:вытекать{}, // вытекать на землю
rus_verbs:вытечь{}, // вытечь на землю
rus_verbs:выучиваться{}, // выучиваться на кого-то
rus_verbs:выучиться{}, // выучиться на кого-то
rus_verbs:посмотреть{}, // посмотреть на экран
rus_verbs:нашить{}, // нашить что-то на одежду
rus_verbs:придти{}, // придти на помощь кому-то
инфинитив:прийти{}, // прийти на помощь кому-то
глагол:прийти{},
деепричастие:придя{}, // Придя на вокзал, он поспешно взял билеты.
rus_verbs:поднять{}, // поднять на вершину
rus_verbs:согласиться{}, // согласиться на ничью
rus_verbs:послать{}, // послать на фронт
rus_verbs:слать{}, // слать на фронт
rus_verbs:надеяться{}, // надеяться на лучшее
rus_verbs:крикнуть{}, // крикнуть на шалунов
rus_verbs:пройти{}, // пройти на пляж
rus_verbs:прислать{}, // прислать на экспертизу
rus_verbs:жить{}, // жить на подачки
rus_verbs:становиться{}, // становиться на ноги
rus_verbs:наслать{}, // наслать на кого-то
rus_verbs:принять{}, // принять на заметку
rus_verbs:собираться{}, // собираться на экзамен
rus_verbs:оставить{}, // оставить на всякий случай
rus_verbs:звать{}, // звать на помощь
rus_verbs:направиться{}, // направиться на прогулку
rus_verbs:отвечать{}, // отвечать на звонки
rus_verbs:отправиться{}, // отправиться на прогулку
rus_verbs:поставить{}, // поставить на пол
rus_verbs:обернуться{}, // обернуться на зов
rus_verbs:отозваться{}, // отозваться на просьбу
rus_verbs:закричать{}, // закричать на собаку
rus_verbs:опустить{}, // опустить на землю
rus_verbs:принести{}, // принести на пляж свой жезлонг
rus_verbs:указать{}, // указать на дверь
rus_verbs:ходить{}, // ходить на занятия
rus_verbs:уставиться{}, // уставиться на листок
rus_verbs:приходить{}, // приходить на экзамен
rus_verbs:махнуть{}, // махнуть на пляж
rus_verbs:явиться{}, // явиться на допрос
rus_verbs:оглянуться{}, // оглянуться на дорогу
rus_verbs:уехать{}, // уехать на заработки
rus_verbs:повести{}, // повести на штурм
rus_verbs:опуститься{}, // опуститься на колени
//rus_verbs:передать{}, // передать на проверку
rus_verbs:побежать{}, // побежать на занятия
rus_verbs:прибыть{}, // прибыть на место службы
rus_verbs:кричать{}, // кричать на медведя
rus_verbs:стечь{}, // стечь на землю
rus_verbs:обратить{}, // обратить на себя внимание
rus_verbs:подать{}, // подать на пропитание
rus_verbs:привести{}, // привести на съемки
rus_verbs:испытывать{}, // испытывать на животных
rus_verbs:перевести{}, // перевести на жену
rus_verbs:купить{}, // купить на заемные деньги
rus_verbs:собраться{}, // собраться на встречу
rus_verbs:заглянуть{}, // заглянуть на огонёк
rus_verbs:нажать{}, // нажать на рычаг
rus_verbs:поспешить{}, // поспешить на праздник
rus_verbs:перейти{}, // перейти на русский язык
rus_verbs:поверить{}, // поверить на честное слово
rus_verbs:глянуть{}, // глянуть на обложку
rus_verbs:зайти{}, // зайти на огонёк
rus_verbs:проходить{}, // проходить на сцену
rus_verbs:глядеть{}, // глядеть на актрису
//rus_verbs:решиться{}, // решиться на прыжок
rus_verbs:пригласить{}, // пригласить на танец
rus_verbs:позвать{}, // позвать на экзамен
rus_verbs:усесться{}, // усесться на стул
rus_verbs:поступить{}, // поступить на математический факультет
rus_verbs:лечь{}, // лечь на живот
rus_verbs:потянуться{}, // потянуться на юг
rus_verbs:присесть{}, // присесть на корточки
rus_verbs:наступить{}, // наступить на змею
rus_verbs:заорать{}, // заорать на попрошаек
rus_verbs:надеть{}, // надеть на голову
rus_verbs:поглядеть{}, // поглядеть на девчонок
rus_verbs:принимать{}, // принимать на гарантийное обслуживание
rus_verbs:привезти{}, // привезти на испытания
rus_verbs:рухнуть{}, // рухнуть на асфальт
rus_verbs:пускать{}, // пускать на корм
rus_verbs:отвести{}, // отвести на приём
rus_verbs:отправить{}, // отправить на утилизацию
rus_verbs:двигаться{}, // двигаться на восток
rus_verbs:нести{}, // нести на пляж
rus_verbs:падать{}, // падать на руки
rus_verbs:откинуться{}, // откинуться на спинку кресла
rus_verbs:рявкнуть{}, // рявкнуть на детей
rus_verbs:получать{}, // получать на проживание
rus_verbs:полезть{}, // полезть на рожон
rus_verbs:направить{}, // направить на дообследование
rus_verbs:приводить{}, // приводить на проверку
rus_verbs:потребоваться{}, // потребоваться на замену
rus_verbs:кинуться{}, // кинуться на нападавшего
rus_verbs:учиться{}, // учиться на токаря
rus_verbs:приподнять{}, // приподнять на один метр
rus_verbs:налить{}, // налить на стол
rus_verbs:играть{}, // играть на деньги
rus_verbs:рассчитывать{}, // рассчитывать на подмогу
rus_verbs:шепнуть{}, // шепнуть на ухо
rus_verbs:швырнуть{}, // швырнуть на землю
rus_verbs:прыгнуть{}, // прыгнуть на оленя
rus_verbs:предлагать{}, // предлагать на выбор
rus_verbs:садиться{}, // садиться на стул
rus_verbs:лить{}, // лить на землю
rus_verbs:испытать{}, // испытать на животных
rus_verbs:фыркнуть{}, // фыркнуть на детеныша
rus_verbs:годиться{}, // мясо годится на фарш
rus_verbs:проверить{}, // проверить высказывание на истинность
rus_verbs:откликнуться{}, // откликнуться на призывы
rus_verbs:полагаться{}, // полагаться на интуицию
rus_verbs:покоситься{}, // покоситься на соседа
rus_verbs:повесить{}, // повесить на гвоздь
инфинитив:походить{вид:соверш}, // походить на занятия
глагол:походить{вид:соверш},
деепричастие:походив{},
прилагательное:походивший{},
rus_verbs:помчаться{}, // помчаться на экзамен
rus_verbs:ставить{}, // ставить на контроль
rus_verbs:свалиться{}, // свалиться на землю
rus_verbs:валиться{}, // валиться на землю
rus_verbs:подарить{}, // подарить на день рожденья
rus_verbs:сбежать{}, // сбежать на необитаемый остров
rus_verbs:стрелять{}, // стрелять на поражение
rus_verbs:обращать{}, // обращать на себя внимание
rus_verbs:наступать{}, // наступать на те же грабли
rus_verbs:сбросить{}, // сбросить на землю
rus_verbs:обидеться{}, // обидеться на друга
rus_verbs:устроиться{}, // устроиться на стажировку
rus_verbs:погрузиться{}, // погрузиться на большую глубину
rus_verbs:течь{}, // течь на землю
rus_verbs:отбросить{}, // отбросить на землю
rus_verbs:метать{}, // метать на дно
rus_verbs:пустить{}, // пустить на переплавку
rus_verbs:прожить{}, // прожить на пособие
rus_verbs:полететь{}, // полететь на континент
rus_verbs:пропустить{}, // пропустить на сцену
rus_verbs:указывать{}, // указывать на ошибку
rus_verbs:наткнуться{}, // наткнуться на клад
rus_verbs:рвануть{}, // рвануть на юг
rus_verbs:ступать{}, // ступать на землю
rus_verbs:спрыгнуть{}, // спрыгнуть на берег
rus_verbs:заходить{}, // заходить на огонёк
rus_verbs:нырнуть{}, // нырнуть на глубину
rus_verbs:рвануться{}, // рвануться на свободу
rus_verbs:натянуть{}, // натянуть на голову
rus_verbs:забраться{}, // забраться на стол
rus_verbs:помахать{}, // помахать на прощание
rus_verbs:содержать{}, // содержать на спонсорскую помощь
rus_verbs:приезжать{}, // приезжать на праздники
rus_verbs:проникнуть{}, // проникнуть на территорию
rus_verbs:подъехать{}, // подъехать на митинг
rus_verbs:устремиться{}, // устремиться на волю
rus_verbs:посадить{}, // посадить на стул
rus_verbs:ринуться{}, // ринуться на голкипера
rus_verbs:подвигнуть{}, // подвигнуть на подвиг
rus_verbs:отдавать{}, // отдавать на перевоспитание
rus_verbs:отложить{}, // отложить на черный день
rus_verbs:убежать{}, // убежать на танцы
rus_verbs:поднимать{}, // поднимать на верхний этаж
rus_verbs:переходить{}, // переходить на цифровой сигнал
rus_verbs:отослать{}, // отослать на переаттестацию
rus_verbs:отодвинуть{}, // отодвинуть на другую половину стола
rus_verbs:назначить{}, // назначить на должность
rus_verbs:осесть{}, // осесть на дно
rus_verbs:торопиться{}, // торопиться на экзамен
rus_verbs:менять{}, // менять на еду
rus_verbs:доставить{}, // доставить на шестой этаж
rus_verbs:заслать{}, // заслать на проверку
rus_verbs:дуть{}, // дуть на воду
rus_verbs:сослать{}, // сослать на каторгу
rus_verbs:останавливаться{}, // останавливаться на отдых
rus_verbs:сдаваться{}, // сдаваться на милость победителя
rus_verbs:сослаться{}, // сослаться на презумпцию невиновности
rus_verbs:рассердиться{}, // рассердиться на дочь
rus_verbs:кинуть{}, // кинуть на землю
rus_verbs:расположиться{}, // расположиться на ночлег
rus_verbs:осмелиться{}, // осмелиться на подлог
rus_verbs:шептать{}, // шептать на ушко
rus_verbs:уронить{}, // уронить на землю
rus_verbs:откинуть{}, // откинуть на спинку кресла
rus_verbs:перенести{}, // перенести на рабочий стол
rus_verbs:сдаться{}, // сдаться на милость победителя
rus_verbs:светить{}, // светить на дорогу
rus_verbs:мчаться{}, // мчаться на бал
rus_verbs:нестись{}, // нестись на свидание
rus_verbs:поглядывать{}, // поглядывать на экран
rus_verbs:орать{}, // орать на детей
rus_verbs:уложить{}, // уложить на лопатки
rus_verbs:решаться{}, // решаться на поступок
rus_verbs:попадать{}, // попадать на карандаш
rus_verbs:сплюнуть{}, // сплюнуть на землю
rus_verbs:снимать{}, // снимать на телефон
rus_verbs:опоздать{}, // опоздать на работу
rus_verbs:посылать{}, // посылать на проверку
rus_verbs:погнать{}, // погнать на пастбище
rus_verbs:поступать{}, // поступать на кибернетический факультет
rus_verbs:спускаться{}, // спускаться на уровень моря
rus_verbs:усадить{}, // усадить на диван
rus_verbs:проиграть{}, // проиграть на спор
rus_verbs:прилететь{}, // прилететь на фестиваль
rus_verbs:повалиться{}, // повалиться на спину
rus_verbs:огрызнуться{}, // Собака огрызнулась на хозяина
rus_verbs:задавать{}, // задавать на выходные
rus_verbs:запасть{}, // запасть на девочку
rus_verbs:лезть{}, // лезть на забор
rus_verbs:потащить{}, // потащить на выборы
rus_verbs:направляться{}, // направляться на экзамен
rus_verbs:определять{}, // определять на вкус
rus_verbs:поползти{}, // поползти на стену
rus_verbs:поплыть{}, // поплыть на берег
rus_verbs:залезть{}, // залезть на яблоню
rus_verbs:сдать{}, // сдать на мясокомбинат
rus_verbs:приземлиться{}, // приземлиться на дорогу
rus_verbs:лаять{}, // лаять на прохожих
rus_verbs:перевернуть{}, // перевернуть на бок
rus_verbs:ловить{}, // ловить на живца
rus_verbs:отнести{}, // отнести животное на хирургический стол
rus_verbs:плюнуть{}, // плюнуть на условности
rus_verbs:передавать{}, // передавать на проверку
rus_verbs:нанять{}, // Босс нанял на работу еще несколько человек
rus_verbs:разозлиться{}, // Папа разозлился на сына из-за плохих оценок по математике
инфинитив:рассыпаться{вид:несоверш}, // рассыпаться на мелкие детали
инфинитив:рассыпаться{вид:соверш},
глагол:рассыпаться{вид:несоверш},
глагол:рассыпаться{вид:соверш},
деепричастие:рассыпавшись{},
деепричастие:рассыпаясь{},
прилагательное:рассыпавшийся{вид:несоверш},
прилагательное:рассыпавшийся{вид:соверш},
прилагательное:рассыпающийся{},
rus_verbs:зарычать{}, // Медведица зарычала на медвежонка
rus_verbs:призвать{}, // призвать на сборы
rus_verbs:увезти{}, // увезти на дачу
rus_verbs:содержаться{}, // содержаться на пожертвования
rus_verbs:навести{}, // навести на скопление телескоп
rus_verbs:отправляться{}, // отправляться на утилизацию
rus_verbs:улечься{}, // улечься на животик
rus_verbs:налететь{}, // налететь на препятствие
rus_verbs:перевернуться{}, // перевернуться на спину
rus_verbs:улететь{}, // улететь на родину
rus_verbs:ложиться{}, // ложиться на бок
rus_verbs:класть{}, // класть на место
rus_verbs:отреагировать{}, // отреагировать на выступление
rus_verbs:доставлять{}, // доставлять на дом
rus_verbs:отнять{}, // отнять на благо правящей верхушки
rus_verbs:ступить{}, // ступить на землю
rus_verbs:сводить{}, // сводить на концерт знаменитой рок-группы
rus_verbs:унести{}, // унести на работу
rus_verbs:сходить{}, // сходить на концерт
rus_verbs:потратить{}, // потратить на корм и наполнитель для туалета все деньги
rus_verbs:соскочить{}, // соскочить на землю
rus_verbs:пожаловаться{}, // пожаловаться на соседей
rus_verbs:тащить{}, // тащить на замену
rus_verbs:замахать{}, // замахать руками на паренька
rus_verbs:заглядывать{}, // заглядывать на обед
rus_verbs:соглашаться{}, // соглашаться на равный обмен
rus_verbs:плюхнуться{}, // плюхнуться на мягкий пуфик
rus_verbs:увести{}, // увести на осмотр
rus_verbs:успевать{}, // успевать на контрольную работу
rus_verbs:опрокинуть{}, // опрокинуть на себя
rus_verbs:подавать{}, // подавать на апелляцию
rus_verbs:прибежать{}, // прибежать на вокзал
rus_verbs:отшвырнуть{}, // отшвырнуть на замлю
rus_verbs:привлекать{}, // привлекать на свою сторону
rus_verbs:опереться{}, // опереться на палку
rus_verbs:перебраться{}, // перебраться на маленький островок
rus_verbs:уговорить{}, // уговорить на новые траты
rus_verbs:гулять{}, // гулять на спонсорские деньги
rus_verbs:переводить{}, // переводить на другой путь
rus_verbs:заколебаться{}, // заколебаться на один миг
rus_verbs:зашептать{}, // зашептать на ушко
rus_verbs:привстать{}, // привстать на цыпочки
rus_verbs:хлынуть{}, // хлынуть на берег
rus_verbs:наброситься{}, // наброситься на еду
rus_verbs:напасть{}, // повстанцы, напавшие на конвой
rus_verbs:убрать{}, // книга, убранная на полку
rus_verbs:попасть{}, // путешественники, попавшие на ничейную территорию
rus_verbs:засматриваться{}, // засматриваться на девчонок
rus_verbs:застегнуться{}, // застегнуться на все пуговицы
rus_verbs:провериться{}, // провериться на заболевания
rus_verbs:проверяться{}, // проверяться на заболевания
rus_verbs:тестировать{}, // тестировать на профпригодность
rus_verbs:протестировать{}, // протестировать на профпригодность
rus_verbs:уходить{}, // отец, уходящий на работу
rus_verbs:налипнуть{}, // снег, налипший на провода
rus_verbs:налипать{}, // снег, налипающий на провода
rus_verbs:улетать{}, // Многие птицы улетают осенью на юг.
rus_verbs:поехать{}, // она поехала на встречу с заказчиком
rus_verbs:переключать{}, // переключать на резервную линию
rus_verbs:переключаться{}, // переключаться на резервную линию
rus_verbs:подписаться{}, // подписаться на обновление
rus_verbs:нанести{}, // нанести на кожу
rus_verbs:нарываться{}, // нарываться на неприятности
rus_verbs:выводить{}, // выводить на орбиту
rus_verbs:вернуться{}, // вернуться на родину
rus_verbs:возвращаться{}, // возвращаться на родину
прилагательное:падкий{}, // Он падок на деньги.
прилагательное:обиженный{}, // Он обижен на отца.
rus_verbs:косить{}, // Он косит на оба глаза.
rus_verbs:закрыть{}, // Он забыл закрыть дверь на замок.
прилагательное:готовый{}, // Он готов на всякие жертвы.
rus_verbs:говорить{}, // Он говорит на скользкую тему.
прилагательное:глухой{}, // Он глух на одно ухо.
rus_verbs:взять{}, // Он взял ребёнка себе на колени.
rus_verbs:оказывать{}, // Лекарство не оказывало на него никакого действия.
rus_verbs:вести{}, // Лестница ведёт на третий этаж.
rus_verbs:уполномочивать{}, // уполномочивать на что-либо
глагол:спешить{ вид:несоверш }, // Я спешу на поезд.
rus_verbs:брать{}, // Я беру всю ответственность на себя.
rus_verbs:произвести{}, // Это произвело на меня глубокое впечатление.
rus_verbs:употребить{}, // Эти деньги можно употребить на ремонт фабрики.
rus_verbs:наводить{}, // Эта песня наводит на меня сон и скуку.
rus_verbs:разбираться{}, // Эта машина разбирается на части.
rus_verbs:оказать{}, // Эта книга оказала на меня большое влияние.
rus_verbs:разбить{}, // Учитель разбил учеников на несколько групп.
rus_verbs:отразиться{}, // Усиленная работа отразилась на его здоровье.
rus_verbs:перегрузить{}, // Уголь надо перегрузить на другое судно.
rus_verbs:делиться{}, // Тридцать делится на пять без остатка.
rus_verbs:удаляться{}, // Суд удаляется на совещание.
rus_verbs:показывать{}, // Стрелка компаса всегда показывает на север.
rus_verbs:сохранить{}, // Сохраните это на память обо мне.
rus_verbs:уезжать{}, // Сейчас все студенты уезжают на экскурсию.
rus_verbs:лететь{}, // Самолёт летит на север.
rus_verbs:бить{}, // Ружьё бьёт на пятьсот метров.
// rus_verbs:прийтись{}, // Пятое число пришлось на субботу.
rus_verbs:вынести{}, // Они вынесли из лодки на берег все вещи.
rus_verbs:смотреть{}, // Она смотрит на нас из окна.
rus_verbs:отдать{}, // Она отдала мне деньги на сохранение.
rus_verbs:налюбоваться{}, // Не могу налюбоваться на картину.
rus_verbs:любоваться{}, // гости любовались на картину
rus_verbs:попробовать{}, // Дайте мне попробовать на ощупь.
прилагательное:действительный{}, // Прививка оспы действительна только на три года.
rus_verbs:спуститься{}, // На город спустился смог
прилагательное:нечистый{}, // Он нечист на руку.
прилагательное:неспособный{}, // Он неспособен на такую низость.
прилагательное:злой{}, // кот очень зол на хозяина
rus_verbs:пойти{}, // Девочка не пошла на урок физультуры
rus_verbs:прибывать{}, // мой поезд прибывает на первый путь
rus_verbs:застегиваться{}, // пальто застегивается на двадцать одну пуговицу
rus_verbs:идти{}, // Дело идёт на лад.
rus_verbs:лазить{}, // Он лазил на чердак.
rus_verbs:поддаваться{}, // Он легко поддаётся на уговоры.
// rus_verbs:действовать{}, // действующий на нервы
rus_verbs:выходить{}, // Балкон выходит на площадь.
rus_verbs:работать{}, // Время работает на нас.
глагол:написать{aux stress="напис^ать"}, // Он написал музыку на слова Пушкина.
rus_verbs:бросить{}, // Они бросили все силы на строительство.
// глагол:разрезать{aux stress="разр^езать"}, глагол:разрезать{aux stress="разрез^ать"}, // Она разрезала пирог на шесть кусков.
rus_verbs:броситься{}, // Она радостно бросилась мне на шею.
rus_verbs:оправдать{}, // Она оправдала неявку на занятия болезнью.
rus_verbs:ответить{}, // Она не ответила на мой поклон.
rus_verbs:нашивать{}, // Она нашивала заплату на локоть.
rus_verbs:молиться{}, // Она молится на свою мать.
rus_verbs:запереть{}, // Она заперла дверь на замок.
rus_verbs:заявить{}, // Она заявила свои права на наследство.
rus_verbs:уйти{}, // Все деньги ушли на путешествие.
rus_verbs:вступить{}, // Водолаз вступил на берег.
rus_verbs:сойти{}, // Ночь сошла на землю.
rus_verbs:приехать{}, // Мы приехали на вокзал слишком рано.
rus_verbs:рыдать{}, // Не рыдай так безумно над ним.
rus_verbs:подписать{}, // Не забудьте подписать меня на газету.
rus_verbs:держать{}, // Наш пароход держал курс прямо на север.
rus_verbs:свезти{}, // На выставку свезли экспонаты со всего мира.
rus_verbs:ехать{}, // Мы сейчас едем на завод.
rus_verbs:выбросить{}, // Волнами лодку выбросило на берег.
ГЛ_ИНФ(сесть), // сесть на снег
ГЛ_ИНФ(записаться),
ГЛ_ИНФ(положить) // положи книгу на стол
}
#endregion VerbList
// Чтобы разрешить связывание в паттернах типа: залить на youtube
fact гл_предл
{
if context { Гл_НА_Вин предлог:на{} @regex("[a-z]+[0-9]*") }
then return true
}
fact гл_предл
{
if context { глагол:купить{} предлог:на{} 'деньги'{падеж:вин} }
then return true
}
fact гл_предл
{
if context { Гл_НА_Вин предлог:на{} *:*{ падеж:вин } }
then return true
}
// смещаться на несколько миллиметров
fact гл_предл
{
if context { Гл_НА_Вин предлог:на{} наречие:*{} }
then return true
}
// партия взяла на себя нереалистичные обязательства
fact гл_предл
{
if context { глагол:взять{} предлог:на{} 'себя'{падеж:вин} }
then return true
}
#endregion ВИНИТЕЛЬНЫЙ
// Все остальные варианты с предлогом 'НА' по умолчанию запрещаем.
fact гл_предл
{
if context { * предлог:на{} *:*{ падеж:предл } }
then return false,-3
}
fact гл_предл
{
if context { * предлог:на{} *:*{ падеж:мест } }
then return false,-3
}
fact гл_предл
{
if context { * предлог:на{} *:*{ падеж:вин } }
then return false,-4
}
// Этот вариант нужен для обработки конструкций с числительными:
// Президентские выборы разделили Венесуэлу на два непримиримых лагеря
fact гл_предл
{
if context { * предлог:на{} *:*{ падеж:род } }
then return false,-4
}
// Продавать на eBay
fact гл_предл
{
if context { * предлог:на{} * }
then return false,-6
}
#endregion Предлог_НА
#region Предлог_С
// ------------- ПРЕДЛОГ 'С' -----------------
// У этого предлога предпочтительная семантика привязывает его обычно к существительному.
// Поэтому запрещаем по умолчанию его привязку к глаголам, а разрешенные глаголы перечислим.
#region ТВОРИТЕЛЬНЫЙ
wordentry_set Гл_С_Твор={
rus_verbs:помогать{}, // будет готов помогать врачам в онкологическом центре с постановкой верных диагнозов
rus_verbs:перепихнуться{}, // неужели ты не хочешь со мной перепихнуться
rus_verbs:забраться{},
rus_verbs:ДРАТЬСЯ{}, // Мои же собственные ратники забросали бы меня гнилой капустой, и мне пришлось бы драться с каждым рыцарем в стране, чтобы доказать свою смелость. (ДРАТЬСЯ/БИТЬСЯ/ПОДРАТЬСЯ)
rus_verbs:БИТЬСЯ{}, //
rus_verbs:ПОДРАТЬСЯ{}, //
прилагательное:СХОЖИЙ{}, // Не был ли он схожим с одним из живых языков Земли (СХОЖИЙ)
rus_verbs:ВСТУПИТЬ{}, // Он намеревался вступить с Вольфом в ближний бой. (ВСТУПИТЬ)
rus_verbs:КОРРЕЛИРОВАТЬ{}, // Это коррелирует с традиционно сильными направлениями московской математической школы. (КОРРЕЛИРОВАТЬ)
rus_verbs:УВИДЕТЬСЯ{}, // Он проигнорирует истерические протесты жены и увидится сначала с доктором, а затем с психотерапевтом (УВИДЕТЬСЯ)
rus_verbs:ОЧНУТЬСЯ{}, // Когда он очнулся с болью в левой стороне черепа, у него возникло пугающее ощущение. (ОЧНУТЬСЯ)
прилагательное:сходный{}, // Мозг этих существ сходен по размерам с мозгом динозавра
rus_verbs:накрыться{}, // Было холодно, и он накрылся с головой одеялом.
rus_verbs:РАСПРЕДЕЛИТЬ{}, // Бюджет распределят с участием горожан (РАСПРЕДЕЛИТЬ)
rus_verbs:НАБРОСИТЬСЯ{}, // Пьяный водитель набросился с ножом на сотрудников ГИБДД (НАБРОСИТЬСЯ)
rus_verbs:БРОСИТЬСЯ{}, // она со смехом бросилась прочь (БРОСИТЬСЯ)
rus_verbs:КОНТАКТИРОВАТЬ{}, // Электронным магазинам стоит контактировать с клиентами (КОНТАКТИРОВАТЬ)
rus_verbs:ВИДЕТЬСЯ{}, // Тогда мы редко виделись друг с другом
rus_verbs:сесть{}, // сел в него с дорожной сумкой , наполненной наркотиками
rus_verbs:купить{}, // Мы купили с ним одну и ту же книгу
rus_verbs:ПРИМЕНЯТЬ{}, // Меры по стимулированию спроса в РФ следует применять с осторожностью (ПРИМЕНЯТЬ)
rus_verbs:УЙТИ{}, // ты мог бы уйти со мной (УЙТИ)
rus_verbs:ЖДАТЬ{}, // С нарастающим любопытством ждем результатов аудита золотых хранилищ европейских и американских центробанков (ЖДАТЬ)
rus_verbs:ГОСПИТАЛИЗИРОВАТЬ{}, // Мэра Твери, участвовавшего в спартакиаде, госпитализировали с инфарктом (ГОСПИТАЛИЗИРОВАТЬ)
rus_verbs:ЗАХЛОПНУТЬСЯ{}, // она захлопнулась со звоном (ЗАХЛОПНУТЬСЯ)
rus_verbs:ОТВЕРНУТЬСЯ{}, // она со вздохом отвернулась (ОТВЕРНУТЬСЯ)
rus_verbs:отправить{}, // вы можете отправить со мной человека
rus_verbs:выступать{}, // Градоначальник , выступая с обзором основных городских событий , поведал об этом депутатам
rus_verbs:ВЫЕЗЖАТЬ{}, // заключенные сами шьют куклы и иногда выезжают с представлениями в детский дом неподалеку (ВЫЕЗЖАТЬ С твор)
rus_verbs:ПОКОНЧИТЬ{}, // со всем этим покончено (ПОКОНЧИТЬ С)
rus_verbs:ПОБЕЖАТЬ{}, // Дмитрий побежал со всеми (ПОБЕЖАТЬ С)
прилагательное:несовместимый{}, // характер ранений был несовместим с жизнью (НЕСОВМЕСТИМЫЙ С)
rus_verbs:ПОСЕТИТЬ{}, // Его кабинет местные тележурналисты посетили со скрытой камерой (ПОСЕТИТЬ С)
rus_verbs:СЛОЖИТЬСЯ{}, // сами банки принимают меры по урегулированию сложившейся с вкладчиками ситуации (СЛОЖИТЬСЯ С)
rus_verbs:ЗАСТАТЬ{}, // Молодой человек убил пенсионера , застав его в постели с женой (ЗАСТАТЬ С)
rus_verbs:ОЗНАКАМЛИВАТЬСЯ{}, // при заполнении заявления владельцы судов ознакамливаются с режимом (ОЗНАКАМЛИВАТЬСЯ С)
rus_verbs:СООБРАЗОВЫВАТЬ{}, // И все свои задачи мы сообразовываем с этим пониманием (СООБРАЗОВЫВАТЬ С)
rus_verbs:СВЫКАТЬСЯ{},
rus_verbs:стаскиваться{},
rus_verbs:спиливаться{},
rus_verbs:КОНКУРИРОВАТЬ{}, // Бедные и менее развитые страны не могут конкурировать с этими субсидиями (КОНКУРИРОВАТЬ С)
rus_verbs:ВЫРВАТЬСЯ{}, // тот с трудом вырвался (ВЫРВАТЬСЯ С твор)
rus_verbs:СОБРАТЬСЯ{}, // нужно собраться с силами (СОБРАТЬСЯ С)
rus_verbs:УДАВАТЬСЯ{}, // удавалось это с трудом (УДАВАТЬСЯ С)
rus_verbs:РАСПАХНУТЬСЯ{}, // дверь с треском распахнулась (РАСПАХНУТЬСЯ С)
rus_verbs:НАБЛЮДАТЬ{}, // Олег наблюдал с любопытством (НАБЛЮДАТЬ С)
rus_verbs:ПОТЯНУТЬ{}, // затем с силой потянул (ПОТЯНУТЬ С)
rus_verbs:КИВНУТЬ{}, // Питер с трудом кивнул (КИВНУТЬ С)
rus_verbs:СГЛОТНУТЬ{}, // Борис с трудом сглотнул (СГЛОТНУТЬ С)
rus_verbs:ЗАБРАТЬ{}, // забрать его с собой (ЗАБРАТЬ С)
rus_verbs:ОТКРЫТЬСЯ{}, // дверь с шипением открылась (ОТКРЫТЬСЯ С)
rus_verbs:ОТОРВАТЬ{}, // с усилием оторвал взгляд (ОТОРВАТЬ С твор)
rus_verbs:ОГЛЯДЕТЬСЯ{}, // Рома с любопытством огляделся (ОГЛЯДЕТЬСЯ С)
rus_verbs:ФЫРКНУТЬ{}, // турок фыркнул с отвращением (ФЫРКНУТЬ С)
rus_verbs:согласиться{}, // с этим согласились все (согласиться с)
rus_verbs:ПОСЫПАТЬСЯ{}, // с грохотом посыпались камни (ПОСЫПАТЬСЯ С твор)
rus_verbs:ВЗДОХНУТЬ{}, // Алиса вздохнула с облегчением (ВЗДОХНУТЬ С)
rus_verbs:ОБЕРНУТЬСЯ{}, // та с удивлением обернулась (ОБЕРНУТЬСЯ С)
rus_verbs:ХМЫКНУТЬ{}, // Алексей хмыкнул с сомнением (ХМЫКНУТЬ С твор)
rus_verbs:ВЫЕХАТЬ{}, // они выехали с рассветом (ВЫЕХАТЬ С твор)
rus_verbs:ВЫДОХНУТЬ{}, // Владимир выдохнул с облегчением (ВЫДОХНУТЬ С)
rus_verbs:УХМЫЛЬНУТЬСЯ{}, // Кеша ухмыльнулся с сомнением (УХМЫЛЬНУТЬСЯ С)
rus_verbs:НЕСТИСЬ{}, // тот несся с криком (НЕСТИСЬ С твор)
rus_verbs:ПАДАТЬ{}, // падают с глухим стуком (ПАДАТЬ С твор)
rus_verbs:ТВОРИТЬСЯ{}, // странное творилось с глазами (ТВОРИТЬСЯ С твор)
rus_verbs:УХОДИТЬ{}, // с ними уходили эльфы (УХОДИТЬ С твор)
rus_verbs:СКАКАТЬ{}, // скакали тут с топорами (СКАКАТЬ С твор)
rus_verbs:ЕСТЬ{}, // здесь едят с зеленью (ЕСТЬ С твор)
rus_verbs:ПОЯВИТЬСЯ{}, // с рассветом появились птицы (ПОЯВИТЬСЯ С твор)
rus_verbs:ВСКОЧИТЬ{}, // Олег вскочил с готовностью (ВСКОЧИТЬ С твор)
rus_verbs:БЫТЬ{}, // хочу быть с тобой (БЫТЬ С твор)
rus_verbs:ПОКАЧАТЬ{}, // с сомнением покачал головой. (ПОКАЧАТЬ С СОМНЕНИЕМ)
rus_verbs:ВЫРУГАТЬСЯ{}, // капитан с чувством выругался (ВЫРУГАТЬСЯ С ЧУВСТВОМ)
rus_verbs:ОТКРЫТЬ{}, // с трудом открыл глаза (ОТКРЫТЬ С ТРУДОМ, таких много)
rus_verbs:ПОЛУЧИТЬСЯ{}, // забавно получилось с ним (ПОЛУЧИТЬСЯ С)
rus_verbs:ВЫБЕЖАТЬ{}, // старый выбежал с копьем (ВЫБЕЖАТЬ С)
rus_verbs:ГОТОВИТЬСЯ{}, // Большинство компотов готовится с использованием сахара (ГОТОВИТЬСЯ С)
rus_verbs:ПОДИСКУТИРОВАТЬ{}, // я бы подискутировал с Андрюхой (ПОДИСКУТИРОВАТЬ С)
rus_verbs:ТУСИТЬ{}, // кто тусил со Светкой (ТУСИТЬ С)
rus_verbs:БЕЖАТЬ{}, // куда она бежит со всеми? (БЕЖАТЬ С твор)
rus_verbs:ГОРЕТЬ{}, // ты горел со своим кораблем? (ГОРЕТЬ С)
rus_verbs:ВЫПИТЬ{}, // хотите выпить со мной чаю? (ВЫПИТЬ С)
rus_verbs:МЕНЯТЬСЯ{}, // Я меняюсь с товарищем книгами. (МЕНЯТЬСЯ С)
rus_verbs:ВАЛЯТЬСЯ{}, // Он уже неделю валяется с гриппом. (ВАЛЯТЬСЯ С)
rus_verbs:ПИТЬ{}, // вы даже будете пить со мной пиво. (ПИТЬ С)
инфинитив:кристаллизоваться{ вид:соверш }, // После этого пересыщенный раствор кристаллизуется с образованием кристаллов сахара.
инфинитив:кристаллизоваться{ вид:несоверш },
глагол:кристаллизоваться{ вид:соверш },
глагол:кристаллизоваться{ вид:несоверш },
rus_verbs:ПООБЩАТЬСЯ{}, // пообщайся с Борисом (ПООБЩАТЬСЯ С)
rus_verbs:ОБМЕНЯТЬСЯ{}, // Миша обменялся с Петей марками (ОБМЕНЯТЬСЯ С)
rus_verbs:ПРОХОДИТЬ{}, // мы с тобой сегодня весь день проходили с вещами. (ПРОХОДИТЬ С)
rus_verbs:ВСТАТЬ{}, // Он занимался всю ночь и встал с головной болью. (ВСТАТЬ С)
rus_verbs:ПОВРЕМЕНИТЬ{}, // МВФ рекомендует Ирландии повременить с мерами экономии (ПОВРЕМЕНИТЬ С)
rus_verbs:ГЛЯДЕТЬ{}, // Её глаза глядели с мягкой грустью. (ГЛЯДЕТЬ С + твор)
rus_verbs:ВЫСКОЧИТЬ{}, // Зачем ты выскочил со своим замечанием? (ВЫСКОЧИТЬ С)
rus_verbs:НЕСТИ{}, // плот несло со страшной силой. (НЕСТИ С)
rus_verbs:приближаться{}, // стена приближалась со страшной быстротой. (приближаться с)
rus_verbs:заниматься{}, // После уроков я занимался с отстающими учениками. (заниматься с)
rus_verbs:разработать{}, // Этот лекарственный препарат разработан с использованием рецептов традиционной китайской медицины. (разработать с)
rus_verbs:вестись{}, // Разработка месторождения ведется с использованием большого количества техники. (вестись с)
rus_verbs:конфликтовать{}, // Маша конфликтует с Петей (конфликтовать с)
rus_verbs:мешать{}, // мешать воду с мукой (мешать с)
rus_verbs:иметь{}, // мне уже приходилось несколько раз иметь с ним дело.
rus_verbs:синхронизировать{}, // синхронизировать с эталонным генератором
rus_verbs:засинхронизировать{}, // засинхронизировать с эталонным генератором
rus_verbs:синхронизироваться{}, // синхронизироваться с эталонным генератором
rus_verbs:засинхронизироваться{}, // засинхронизироваться с эталонным генератором
rus_verbs:стирать{}, // стирать с мылом рубашку в тазу
rus_verbs:прыгать{}, // парашютист прыгает с парашютом
rus_verbs:выступить{}, // Он выступил с приветствием съезду.
rus_verbs:ходить{}, // В чужой монастырь со своим уставом не ходят.
rus_verbs:отозваться{}, // Он отозвался об этой книге с большой похвалой.
rus_verbs:отзываться{}, // Он отзывается об этой книге с большой похвалой.
rus_verbs:вставать{}, // он встаёт с зарёй
rus_verbs:мирить{}, // Его ум мирил всех с его дурным характером.
rus_verbs:продолжаться{}, // стрельба тем временем продолжалась с прежней точностью.
rus_verbs:договориться{}, // мы договоримся с вами
rus_verbs:побыть{}, // он хотел побыть с тобой
rus_verbs:расти{}, // Мировые производственные мощности растут с беспрецедентной скоростью
rus_verbs:вязаться{}, // вязаться с фактами
rus_verbs:отнестись{}, // отнестись к животным с сочуствием
rus_verbs:относиться{}, // относиться с пониманием
rus_verbs:пойти{}, // Спектакль пойдёт с участием известных артистов.
rus_verbs:бракосочетаться{}, // Потомственный кузнец бракосочетался с разорившейся графиней
rus_verbs:гулять{}, // бабушка гуляет с внуком
rus_verbs:разбираться{}, // разбираться с задачей
rus_verbs:сверить{}, // Данные были сверены с эталонными значениями
rus_verbs:делать{}, // Что делать со старым телефоном
rus_verbs:осматривать{}, // осматривать с удивлением
rus_verbs:обсудить{}, // обсудить с приятелем прохождение уровня в новой игре
rus_verbs:попрощаться{}, // попрощаться с талантливым актером
rus_verbs:задремать{}, // задремать с кружкой чая в руке
rus_verbs:связать{}, // связать катастрофу с действиями конкурентов
rus_verbs:носиться{}, // носиться с безумной идеей
rus_verbs:кончать{}, // кончать с собой
rus_verbs:обмениваться{}, // обмениваться с собеседниками
rus_verbs:переговариваться{}, // переговариваться с маяком
rus_verbs:общаться{}, // общаться с полицией
rus_verbs:завершить{}, // завершить с ошибкой
rus_verbs:обняться{}, // обняться с подругой
rus_verbs:сливаться{}, // сливаться с фоном
rus_verbs:смешаться{}, // смешаться с толпой
rus_verbs:договариваться{}, // договариваться с потерпевшим
rus_verbs:обедать{}, // обедать с гостями
rus_verbs:сообщаться{}, // сообщаться с подземной рекой
rus_verbs:сталкиваться{}, // сталкиваться со стаей птиц
rus_verbs:читаться{}, // читаться с трудом
rus_verbs:смириться{}, // смириться с утратой
rus_verbs:разделить{}, // разделить с другими ответственность
rus_verbs:роднить{}, // роднить с медведем
rus_verbs:медлить{}, // медлить с ответом
rus_verbs:скрестить{}, // скрестить с ужом
rus_verbs:покоиться{}, // покоиться с миром
rus_verbs:делиться{}, // делиться с друзьями
rus_verbs:познакомить{}, // познакомить с Олей
rus_verbs:порвать{}, // порвать с Олей
rus_verbs:завязать{}, // завязать с Олей знакомство
rus_verbs:суетиться{}, // суетиться с изданием романа
rus_verbs:соединиться{}, // соединиться с сервером
rus_verbs:справляться{}, // справляться с нуждой
rus_verbs:замешкаться{}, // замешкаться с ответом
rus_verbs:поссориться{}, // поссориться с подругой
rus_verbs:ссориться{}, // ссориться с друзьями
rus_verbs:торопить{}, // торопить с решением
rus_verbs:поздравить{}, // поздравить с победой
rus_verbs:проститься{}, // проститься с человеком
rus_verbs:поработать{}, // поработать с деревом
rus_verbs:приключиться{}, // приключиться с Колей
rus_verbs:сговориться{}, // сговориться с Ваней
rus_verbs:отъехать{}, // отъехать с ревом
rus_verbs:объединять{}, // объединять с другой кампанией
rus_verbs:употребить{}, // употребить с молоком
rus_verbs:перепутать{}, // перепутать с другой книгой
rus_verbs:запоздать{}, // запоздать с ответом
rus_verbs:подружиться{}, // подружиться с другими детьми
rus_verbs:дружить{}, // дружить с Сережей
rus_verbs:поравняться{}, // поравняться с финишной чертой
rus_verbs:ужинать{}, // ужинать с гостями
rus_verbs:расставаться{}, // расставаться с приятелями
rus_verbs:завтракать{}, // завтракать с семьей
rus_verbs:объединиться{}, // объединиться с соседями
rus_verbs:сменяться{}, // сменяться с напарником
rus_verbs:соединить{}, // соединить с сетью
rus_verbs:разговориться{}, // разговориться с охранником
rus_verbs:преподнести{}, // преподнести с помпой
rus_verbs:напечатать{}, // напечатать с картинками
rus_verbs:соединять{}, // соединять с сетью
rus_verbs:расправиться{}, // расправиться с беззащитным человеком
rus_verbs:распрощаться{}, // распрощаться с деньгами
rus_verbs:сравнить{}, // сравнить с конкурентами
rus_verbs:ознакомиться{}, // ознакомиться с выступлением
инфинитив:сочетаться{ вид:несоверш }, глагол:сочетаться{ вид:несоверш }, // сочетаться с сумочкой
деепричастие:сочетаясь{}, прилагательное:сочетающийся{}, прилагательное:сочетавшийся{},
rus_verbs:изнасиловать{}, // изнасиловать с применением чрезвычайного насилия
rus_verbs:прощаться{}, // прощаться с боевым товарищем
rus_verbs:сравнивать{}, // сравнивать с конкурентами
rus_verbs:складывать{}, // складывать с весом упаковки
rus_verbs:повестись{}, // повестись с ворами
rus_verbs:столкнуть{}, // столкнуть с отбойником
rus_verbs:переглядываться{}, // переглядываться с соседом
rus_verbs:поторопить{}, // поторопить с откликом
rus_verbs:развлекаться{}, // развлекаться с подружками
rus_verbs:заговаривать{}, // заговаривать с незнакомцами
rus_verbs:поцеловаться{}, // поцеловаться с первой девушкой
инфинитив:согласоваться{ вид:несоверш }, глагол:согласоваться{ вид:несоверш }, // согласоваться с подлежащим
деепричастие:согласуясь{}, прилагательное:согласующийся{},
rus_verbs:совпасть{}, // совпасть с оригиналом
rus_verbs:соединяться{}, // соединяться с куратором
rus_verbs:повстречаться{}, // повстречаться с героями
rus_verbs:поужинать{}, // поужинать с родителями
rus_verbs:развестись{}, // развестись с первым мужем
rus_verbs:переговорить{}, // переговорить с коллегами
rus_verbs:сцепиться{}, // сцепиться с бродячей собакой
rus_verbs:сожрать{}, // сожрать с потрохами
rus_verbs:побеседовать{}, // побеседовать со шпаной
rus_verbs:поиграть{}, // поиграть с котятами
rus_verbs:сцепить{}, // сцепить с тягачом
rus_verbs:помириться{}, // помириться с подружкой
rus_verbs:связываться{}, // связываться с бандитами
rus_verbs:совещаться{}, // совещаться с мастерами
rus_verbs:обрушиваться{}, // обрушиваться с беспощадной критикой
rus_verbs:переплестись{}, // переплестись с кустами
rus_verbs:мутить{}, // мутить с одногрупницами
rus_verbs:приглядываться{}, // приглядываться с интересом
rus_verbs:сблизиться{}, // сблизиться с врагами
rus_verbs:перешептываться{}, // перешептываться с симпатичной соседкой
rus_verbs:растереть{}, // растереть с солью
rus_verbs:смешиваться{}, // смешиваться с известью
rus_verbs:соприкоснуться{}, // соприкоснуться с тайной
rus_verbs:ладить{}, // ладить с родственниками
rus_verbs:сотрудничать{}, // сотрудничать с органами дознания
rus_verbs:съехаться{}, // съехаться с родственниками
rus_verbs:перекинуться{}, // перекинуться с коллегами парой слов
rus_verbs:советоваться{}, // советоваться с отчимом
rus_verbs:сравниться{}, // сравниться с лучшими
rus_verbs:знакомиться{}, // знакомиться с абитуриентами
rus_verbs:нырять{}, // нырять с аквалангом
rus_verbs:забавляться{}, // забавляться с куклой
rus_verbs:перекликаться{}, // перекликаться с другой статьей
rus_verbs:тренироваться{}, // тренироваться с партнершей
rus_verbs:поспорить{}, // поспорить с казночеем
инфинитив:сладить{ вид:соверш }, глагол:сладить{ вид:соверш }, // сладить с бычком
деепричастие:сладив{}, прилагательное:сладивший{ вид:соверш },
rus_verbs:примириться{}, // примириться с утратой
rus_verbs:раскланяться{}, // раскланяться с фрейлинами
rus_verbs:слечь{}, // слечь с ангиной
rus_verbs:соприкасаться{}, // соприкасаться со стеной
rus_verbs:смешать{}, // смешать с грязью
rus_verbs:пересекаться{}, // пересекаться с трассой
rus_verbs:путать{}, // путать с государственной шерстью
rus_verbs:поболтать{}, // поболтать с ученицами
rus_verbs:здороваться{}, // здороваться с профессором
rus_verbs:просчитаться{}, // просчитаться с покупкой
rus_verbs:сторожить{}, // сторожить с собакой
rus_verbs:обыскивать{}, // обыскивать с собаками
rus_verbs:переплетаться{}, // переплетаться с другой веткой
rus_verbs:обниматься{}, // обниматься с Ксюшей
rus_verbs:объединяться{}, // объединяться с конкурентами
rus_verbs:погорячиться{}, // погорячиться с покупкой
rus_verbs:мыться{}, // мыться с мылом
rus_verbs:свериться{}, // свериться с эталоном
rus_verbs:разделаться{}, // разделаться с кем-то
rus_verbs:чередоваться{}, // чередоваться с партнером
rus_verbs:налететь{}, // налететь с соратниками
rus_verbs:поспать{}, // поспать с включенным светом
rus_verbs:управиться{}, // управиться с собакой
rus_verbs:согрешить{}, // согрешить с замужней
rus_verbs:определиться{}, // определиться с победителем
rus_verbs:перемешаться{}, // перемешаться с гранулами
rus_verbs:затрудняться{}, // затрудняться с ответом
rus_verbs:обождать{}, // обождать со стартом
rus_verbs:фыркать{}, // фыркать с презрением
rus_verbs:засидеться{}, // засидеться с приятелем
rus_verbs:крепнуть{}, // крепнуть с годами
rus_verbs:пировать{}, // пировать с дружиной
rus_verbs:щебетать{}, // щебетать с сестричками
rus_verbs:маяться{}, // маяться с кашлем
rus_verbs:сближать{}, // сближать с центральным светилом
rus_verbs:меркнуть{}, // меркнуть с возрастом
rus_verbs:заспорить{}, // заспорить с оппонентами
rus_verbs:граничить{}, // граничить с Ливаном
rus_verbs:перестараться{}, // перестараться со стимуляторами
rus_verbs:объединить{}, // объединить с филиалом
rus_verbs:свыкнуться{}, // свыкнуться с утратой
rus_verbs:посоветоваться{}, // посоветоваться с адвокатами
rus_verbs:напутать{}, // напутать с ведомостями
rus_verbs:нагрянуть{}, // нагрянуть с обыском
rus_verbs:посовещаться{}, // посовещаться с судьей
rus_verbs:провернуть{}, // провернуть с друганом
rus_verbs:разделяться{}, // разделяться с сотрапезниками
rus_verbs:пересечься{}, // пересечься с второй колонной
rus_verbs:опережать{}, // опережать с большим запасом
rus_verbs:перепутаться{}, // перепутаться с другой линией
rus_verbs:соотноситься{}, // соотноситься с затратами
rus_verbs:смешивать{}, // смешивать с золой
rus_verbs:свидеться{}, // свидеться с тобой
rus_verbs:переспать{}, // переспать с графиней
rus_verbs:поладить{}, // поладить с соседями
rus_verbs:протащить{}, // протащить с собой
rus_verbs:разминуться{}, // разминуться с встречным потоком
rus_verbs:перемежаться{}, // перемежаться с успехами
rus_verbs:рассчитаться{}, // рассчитаться с кредиторами
rus_verbs:срастись{}, // срастись с телом
rus_verbs:знакомить{}, // знакомить с родителями
rus_verbs:поругаться{}, // поругаться с родителями
rus_verbs:совладать{}, // совладать с чувствами
rus_verbs:обручить{}, // обручить с богатой невестой
rus_verbs:сближаться{}, // сближаться с вражеским эсминцем
rus_verbs:замутить{}, // замутить с Ксюшей
rus_verbs:повозиться{}, // повозиться с настройкой
rus_verbs:торговаться{}, // торговаться с продавцами
rus_verbs:уединиться{}, // уединиться с девчонкой
rus_verbs:переборщить{}, // переборщить с добавкой
rus_verbs:ознакомить{}, // ознакомить с пожеланиями
rus_verbs:прочесывать{}, // прочесывать с собаками
rus_verbs:переписываться{}, // переписываться с корреспондентами
rus_verbs:повздорить{}, // повздорить с сержантом
rus_verbs:разлучить{}, // разлучить с семьей
rus_verbs:соседствовать{}, // соседствовать с цыганами
rus_verbs:застукать{}, // застукать с проститутками
rus_verbs:напуститься{}, // напуститься с кулаками
rus_verbs:сдружиться{}, // сдружиться с ребятами
rus_verbs:соперничать{}, // соперничать с параллельным классом
rus_verbs:прочесать{}, // прочесать с собаками
rus_verbs:кокетничать{}, // кокетничать с гимназистками
rus_verbs:мириться{}, // мириться с убытками
rus_verbs:оплошать{}, // оплошать с билетами
rus_verbs:отождествлять{}, // отождествлять с литературным героем
rus_verbs:хитрить{}, // хитрить с зарплатой
rus_verbs:провозиться{}, // провозиться с задачкой
rus_verbs:коротать{}, // коротать с друзьями
rus_verbs:соревноваться{}, // соревноваться с машиной
rus_verbs:уживаться{}, // уживаться с местными жителями
rus_verbs:отождествляться{}, // отождествляться с литературным героем
rus_verbs:сопоставить{}, // сопоставить с эталоном
rus_verbs:пьянствовать{}, // пьянствовать с друзьями
rus_verbs:залетать{}, // залетать с паленой водкой
rus_verbs:гастролировать{}, // гастролировать с новой цирковой программой
rus_verbs:запаздывать{}, // запаздывать с кормлением
rus_verbs:таскаться{}, // таскаться с сумками
rus_verbs:контрастировать{}, // контрастировать с туфлями
rus_verbs:сшибиться{}, // сшибиться с форвардом
rus_verbs:состязаться{}, // состязаться с лучшей командой
rus_verbs:затрудниться{}, // затрудниться с объяснением
rus_verbs:объясниться{}, // объясниться с пострадавшими
rus_verbs:разводиться{}, // разводиться со сварливой женой
rus_verbs:препираться{}, // препираться с адвокатами
rus_verbs:сосуществовать{}, // сосуществовать с крупными хищниками
rus_verbs:свестись{}, // свестись с нулевым счетом
rus_verbs:обговорить{}, // обговорить с директором
rus_verbs:обвенчаться{}, // обвенчаться с ведьмой
rus_verbs:экспериментировать{}, // экспериментировать с генами
rus_verbs:сверять{}, // сверять с таблицей
rus_verbs:сверяться{}, // свериться с таблицей
rus_verbs:сблизить{}, // сблизить с точкой
rus_verbs:гармонировать{}, // гармонировать с обоями
rus_verbs:перемешивать{}, // перемешивать с молоком
rus_verbs:трепаться{}, // трепаться с сослуживцами
rus_verbs:перемигиваться{}, // перемигиваться с соседкой
rus_verbs:разоткровенничаться{}, // разоткровенничаться с незнакомцем
rus_verbs:распить{}, // распить с собутыльниками
rus_verbs:скрестись{}, // скрестись с дикой лошадью
rus_verbs:передраться{}, // передраться с дворовыми собаками
rus_verbs:умыть{}, // умыть с мылом
rus_verbs:грызться{}, // грызться с соседями
rus_verbs:переругиваться{}, // переругиваться с соседями
rus_verbs:доиграться{}, // доиграться со спичками
rus_verbs:заладиться{}, // заладиться с подругой
rus_verbs:скрещиваться{}, // скрещиваться с дикими видами
rus_verbs:повидаться{}, // повидаться с дедушкой
rus_verbs:повоевать{}, // повоевать с орками
rus_verbs:сразиться{}, // сразиться с лучшим рыцарем
rus_verbs:кипятить{}, // кипятить с отбеливателем
rus_verbs:усердствовать{}, // усердствовать с наказанием
rus_verbs:схлестнуться{}, // схлестнуться с лучшим боксером
rus_verbs:пошептаться{}, // пошептаться с судьями
rus_verbs:сравняться{}, // сравняться с лучшими экземплярами
rus_verbs:церемониться{}, // церемониться с пьяницами
rus_verbs:консультироваться{}, // консультироваться со специалистами
rus_verbs:переусердствовать{}, // переусердствовать с наказанием
rus_verbs:проноситься{}, // проноситься с собой
rus_verbs:перемешать{}, // перемешать с гипсом
rus_verbs:темнить{}, // темнить с долгами
rus_verbs:сталкивать{}, // сталкивать с черной дырой
rus_verbs:увольнять{}, // увольнять с волчьим билетом
rus_verbs:заигрывать{}, // заигрывать с совершенно диким животным
rus_verbs:сопоставлять{}, // сопоставлять с эталонными образцами
rus_verbs:расторгнуть{}, // расторгнуть с нерасторопными поставщиками долгосрочный контракт
rus_verbs:созвониться{}, // созвониться с мамой
rus_verbs:спеться{}, // спеться с отъявленными хулиганами
rus_verbs:интриговать{}, // интриговать с придворными
rus_verbs:приобрести{}, // приобрести со скидкой
rus_verbs:задержаться{}, // задержаться со сдачей работы
rus_verbs:плавать{}, // плавать со спасательным кругом
rus_verbs:якшаться{}, // Не якшайся с врагами
инфинитив:ассоциировать{вид:соверш}, // читатели ассоциируют с собой героя книги
инфинитив:ассоциировать{вид:несоверш},
глагол:ассоциировать{вид:соверш}, // читатели ассоциируют с собой героя книги
глагол:ассоциировать{вид:несоверш},
//+прилагательное:ассоциировавший{вид:несоверш},
прилагательное:ассоциировавший{вид:соверш},
прилагательное:ассоциирующий{},
деепричастие:ассоциируя{},
деепричастие:ассоциировав{},
rus_verbs:ассоциироваться{}, // герой книги ассоциируется с реальным персонажем
rus_verbs:аттестовывать{}, // Они аттестовывают сотрудников с помощью наборра тестов
rus_verbs:аттестовываться{}, // Сотрудники аттестовываются с помощью набора тестов
//+инфинитив:аффилировать{вид:соверш}, // эти предприятия были аффилированы с олигархом
//+глагол:аффилировать{вид:соверш},
прилагательное:аффилированный{},
rus_verbs:баловаться{}, // мальчик баловался с молотком
rus_verbs:балясничать{}, // женщина балясничала с товарками
rus_verbs:богатеть{}, // Провинция богатеет от торговли с соседями
rus_verbs:бодаться{}, // теленок бодается с деревом
rus_verbs:боксировать{}, // Майкл дважды боксировал с ним
rus_verbs:брататься{}, // Солдаты братались с бойцами союзников
rus_verbs:вальсировать{}, // Мальчик вальсирует с девочкой
rus_verbs:вверстывать{}, // Дизайнер с трудом вверстывает блоки в страницу
rus_verbs:происходить{}, // Что происходит с мировой экономикой?
rus_verbs:произойти{}, // Что произошло с экономикой?
rus_verbs:взаимодействовать{}, // Электроны взаимодействуют с фотонами
rus_verbs:вздорить{}, // Эта женщина часто вздорила с соседями
rus_verbs:сойтись{}, // Мальчик сошелся с бандой хулиганов
rus_verbs:вобрать{}, // вобрать в себя лучшие методы борьбы с вредителями
rus_verbs:водиться{}, // Няня водится с детьми
rus_verbs:воевать{}, // Фермеры воевали с волками
rus_verbs:возиться{}, // Няня возится с детьми
rus_verbs:ворковать{}, // Голубь воркует с голубкой
rus_verbs:воссоединиться{}, // Дети воссоединились с семьей
rus_verbs:воссоединяться{}, // Дети воссоединяются с семьей
rus_verbs:вошкаться{}, // Не вошкайся с этой ерундой
rus_verbs:враждовать{}, // враждовать с соседями
rus_verbs:временить{}, // временить с выходом на пенсию
rus_verbs:расстаться{}, // я не могу расстаться с тобой
rus_verbs:выдирать{}, // выдирать с мясом
rus_verbs:выдираться{}, // выдираться с мясом
rus_verbs:вытворить{}, // вытворить что-либо с чем-либо
rus_verbs:вытворять{}, // вытворять что-либо с чем-либо
rus_verbs:сделать{}, // сделать с чем-то
rus_verbs:домыть{}, // домыть с мылом
rus_verbs:случиться{}, // случиться с кем-то
rus_verbs:остаться{}, // остаться с кем-то
rus_verbs:случать{}, // случать с породистым кобельком
rus_verbs:послать{}, // послать с весточкой
rus_verbs:работать{}, // работать с роботами
rus_verbs:провести{}, // провести с девчонками время
rus_verbs:заговорить{}, // заговорить с незнакомкой
rus_verbs:прошептать{}, // прошептать с придыханием
rus_verbs:читать{}, // читать с выражением
rus_verbs:слушать{}, // слушать с повышенным вниманием
rus_verbs:принести{}, // принести с собой
rus_verbs:спать{}, // спать с женщинами
rus_verbs:закончить{}, // закончить с приготовлениями
rus_verbs:помочь{}, // помочь с перестановкой
rus_verbs:уехать{}, // уехать с семьей
rus_verbs:случаться{}, // случаться с кем-то
rus_verbs:кутить{}, // кутить с проститутками
rus_verbs:разговаривать{}, // разговаривать с ребенком
rus_verbs:погодить{}, // погодить с ликвидацией
rus_verbs:считаться{}, // считаться с чужим мнением
rus_verbs:носить{}, // носить с собой
rus_verbs:хорошеть{}, // хорошеть с каждым днем
rus_verbs:приводить{}, // приводить с собой
rus_verbs:прыгнуть{}, // прыгнуть с парашютом
rus_verbs:петь{}, // петь с чувством
rus_verbs:сложить{}, // сложить с результатом
rus_verbs:познакомиться{}, // познакомиться с другими студентами
rus_verbs:обращаться{}, // обращаться с животными
rus_verbs:съесть{}, // съесть с хлебом
rus_verbs:ошибаться{}, // ошибаться с дозировкой
rus_verbs:столкнуться{}, // столкнуться с медведем
rus_verbs:справиться{}, // справиться с нуждой
rus_verbs:торопиться{}, // торопиться с ответом
rus_verbs:поздравлять{}, // поздравлять с победой
rus_verbs:объясняться{}, // объясняться с начальством
rus_verbs:пошутить{}, // пошутить с подругой
rus_verbs:поздороваться{}, // поздороваться с коллегами
rus_verbs:поступать{}, // Как поступать с таким поведением?
rus_verbs:определяться{}, // определяться с кандидатами
rus_verbs:связаться{}, // связаться с поставщиком
rus_verbs:спорить{}, // спорить с собеседником
rus_verbs:разобраться{}, // разобраться с делами
rus_verbs:ловить{}, // ловить с удочкой
rus_verbs:помедлить{}, // Кандидат помедлил с ответом на заданный вопрос
rus_verbs:шутить{}, // шутить с диким зверем
rus_verbs:разорвать{}, // разорвать с поставщиком контракт
rus_verbs:увезти{}, // увезти с собой
rus_verbs:унести{}, // унести с собой
rus_verbs:сотворить{}, // сотворить с собой что-то нехорошее
rus_verbs:складываться{}, // складываться с первым импульсом
rus_verbs:соглашаться{}, // соглашаться с предложенным договором
//rus_verbs:покончить{}, // покончить с развратом
rus_verbs:прихватить{}, // прихватить с собой
rus_verbs:похоронить{}, // похоронить с почестями
rus_verbs:связывать{}, // связывать с компанией свою судьбу
rus_verbs:совпадать{}, // совпадать с предсказанием
rus_verbs:танцевать{}, // танцевать с девушками
rus_verbs:поделиться{}, // поделиться с выжившими
rus_verbs:оставаться{}, // я не хотел оставаться с ним в одной комнате.
rus_verbs:беседовать{}, // преподаватель, беседующий со студентами
rus_verbs:бороться{}, // человек, борющийся со смертельной болезнью
rus_verbs:шептаться{}, // девочка, шепчущаяся с подругой
rus_verbs:сплетничать{}, // женщина, сплетничавшая с товарками
rus_verbs:поговорить{}, // поговорить с виновниками
rus_verbs:сказать{}, // сказать с трудом
rus_verbs:произнести{}, // произнести с трудом
rus_verbs:говорить{}, // говорить с акцентом
rus_verbs:произносить{}, // произносить с трудом
rus_verbs:встречаться{}, // кто с Антонио встречался?
rus_verbs:посидеть{}, // посидеть с друзьями
rus_verbs:расквитаться{}, // расквитаться с обидчиком
rus_verbs:поквитаться{}, // поквитаться с обидчиком
rus_verbs:ругаться{}, // ругаться с женой
rus_verbs:поскандалить{}, // поскандалить с женой
rus_verbs:потанцевать{}, // потанцевать с подругой
rus_verbs:скандалить{}, // скандалить с соседями
rus_verbs:разругаться{}, // разругаться с другом
rus_verbs:болтать{}, // болтать с подругами
rus_verbs:потрепаться{}, // потрепаться с соседкой
rus_verbs:войти{}, // войти с регистрацией
rus_verbs:входить{}, // входить с регистрацией
rus_verbs:возвращаться{}, // возвращаться с триумфом
rus_verbs:опоздать{}, // Он опоздал с подачей сочинения.
rus_verbs:молчать{}, // Он молчал с ледяным спокойствием.
rus_verbs:сражаться{}, // Он героически сражался с врагами.
rus_verbs:выходить{}, // Он всегда выходит с зонтиком.
rus_verbs:сличать{}, // сличать перевод с оригиналом
rus_verbs:начать{}, // я начал с товарищем спор о религии
rus_verbs:согласовать{}, // Маша согласовала с Петей дальнейшие поездки
rus_verbs:приходить{}, // Приходите с нею.
rus_verbs:жить{}, // кто с тобой жил?
rus_verbs:расходиться{}, // Маша расходится с Петей
rus_verbs:сцеплять{}, // сцеплять карабин с обвязкой
rus_verbs:торговать{}, // мы торгуем с ними нефтью
rus_verbs:уединяться{}, // уединяться с подругой в доме
rus_verbs:уладить{}, // уладить конфликт с соседями
rus_verbs:идти{}, // Я шел туда с тяжёлым сердцем.
rus_verbs:разделять{}, // Я разделяю с вами горе и радость.
rus_verbs:обратиться{}, // Я обратился к нему с просьбой о помощи.
rus_verbs:захватить{}, // Я не захватил с собой денег.
прилагательное:знакомый{}, // Я знаком с ними обоими.
rus_verbs:вести{}, // Я веду с ней переписку.
прилагательное:сопряженный{}, // Это сопряжено с большими трудностями.
прилагательное:связанный{причастие}, // Это дело связано с риском.
rus_verbs:поехать{}, // Хотите поехать со мной в театр?
rus_verbs:проснуться{}, // Утром я проснулся с ясной головой.
rus_verbs:лететь{}, // Самолёт летел со скоростью звука.
rus_verbs:играть{}, // С огнём играть опасно!
rus_verbs:поделать{}, // С ним ничего не поделаешь.
rus_verbs:стрястись{}, // С ней стряслось несчастье.
rus_verbs:смотреться{}, // Пьеса смотрится с удовольствием.
rus_verbs:смотреть{}, // Она смотрела на меня с явным неудовольствием.
rus_verbs:разойтись{}, // Она разошлась с мужем.
rus_verbs:пристать{}, // Она пристала ко мне с расспросами.
rus_verbs:посмотреть{}, // Она посмотрела на меня с удивлением.
rus_verbs:поступить{}, // Она плохо поступила с ним.
rus_verbs:выйти{}, // Она вышла с усталым и недовольным видом.
rus_verbs:взять{}, // Возьмите с собой только самое необходимое.
rus_verbs:наплакаться{}, // Наплачется она с ним.
rus_verbs:лежать{}, // Он лежит с воспалением лёгких.
rus_verbs:дышать{}, // дышащий с трудом
rus_verbs:брать{}, // брать с собой
rus_verbs:мчаться{}, // Автомобиль мчится с необычайной быстротой.
rus_verbs:упасть{}, // Ваза упала со звоном.
rus_verbs:вернуться{}, // мы вернулись вчера домой с полным лукошком
rus_verbs:сидеть{}, // Она сидит дома с ребенком
rus_verbs:встретиться{}, // встречаться с кем-либо
ГЛ_ИНФ(придти), прилагательное:пришедший{}, // пришедший с другом
ГЛ_ИНФ(постирать), прилагательное:постиранный{}, деепричастие:постирав{},
rus_verbs:мыть{}
}
fact гл_предл
{
if context { Гл_С_Твор предлог:с{} @regex("[a-z]+[0-9]*") }
then return true
}
fact гл_предл
{
if context { Гл_С_Твор предлог:с{} *:*{падеж:твор} }
then return true
}
#endregion ТВОРИТЕЛЬНЫЙ
#region РОДИТЕЛЬНЫЙ
wordentry_set Гл_С_Род=
{
rus_verbs:УХОДИТЬ{}, // Но с базы не уходить.
rus_verbs:РВАНУТЬ{}, // Водитель прорычал проклятие и рванул машину с места. (РВАНУТЬ)
rus_verbs:ОХВАТИТЬ{}, // огонь охватил его со всех сторон (ОХВАТИТЬ)
rus_verbs:ЗАМЕТИТЬ{}, // Он понимал, что свет из тайника невозможно заметить с палубы (ЗАМЕТИТЬ/РАЗГЛЯДЕТЬ)
rus_verbs:РАЗГЛЯДЕТЬ{}, //
rus_verbs:СПЛАНИРОВАТЬ{}, // Птицы размером с орлицу, вероятно, не могли бы подняться в воздух, не спланировав с высокого утеса. (СПЛАНИРОВАТЬ)
rus_verbs:УМЕРЕТЬ{}, // Он умрет с голоду. (УМЕРЕТЬ)
rus_verbs:ВСПУГНУТЬ{}, // Оба упали с лязгом, вспугнувшим птиц с ближайших деревьев (ВСПУГНУТЬ)
rus_verbs:РЕВЕТЬ{}, // Время от времени какой-то ящер ревел с берега или самой реки. (РЕВЕТЬ/ЗАРЕВЕТЬ/ПРОРЕВЕТЬ/ЗАОРАТЬ/ПРООРАТЬ/ОРАТЬ/ПРОКРИЧАТЬ/ЗАКРИЧАТЬ/ВОПИТЬ/ЗАВОПИТЬ)
rus_verbs:ЗАРЕВЕТЬ{}, //
rus_verbs:ПРОРЕВЕТЬ{}, //
rus_verbs:ЗАОРАТЬ{}, //
rus_verbs:ПРООРАТЬ{}, //
rus_verbs:ОРАТЬ{}, //
rus_verbs:ЗАКРИЧАТЬ{},
rus_verbs:ВОПИТЬ{}, //
rus_verbs:ЗАВОПИТЬ{}, //
rus_verbs:СТАЩИТЬ{}, // Я видела как они стащили его с валуна и увели с собой. (СТАЩИТЬ/СТАСКИВАТЬ)
rus_verbs:СТАСКИВАТЬ{}, //
rus_verbs:ПРОВЫТЬ{}, // Призрак трубного зова провыл с другой стороны дверей. (ПРОВЫТЬ, ЗАВЫТЬ, ВЫТЬ)
rus_verbs:ЗАВЫТЬ{}, //
rus_verbs:ВЫТЬ{}, //
rus_verbs:СВЕТИТЬ{}, // Полуденное майское солнце ярко светило с голубых небес Аризоны. (СВЕТИТЬ)
rus_verbs:ОТСВЕЧИВАТЬ{}, // Солнце отсвечивало с белых лошадей, белых щитов и белых перьев и искрилось на наконечниках пик. (ОТСВЕЧИВАТЬ С, ИСКРИТЬСЯ НА)
rus_verbs:перегнать{}, // Скот нужно перегнать с этого пастбища на другое
rus_verbs:собирать{}, // мальчики начали собирать со столов посуду
rus_verbs:разглядывать{}, // ты ее со всех сторон разглядывал
rus_verbs:СЖИМАТЬ{}, // меня плотно сжимали со всех сторон (СЖИМАТЬ)
rus_verbs:СОБРАТЬСЯ{}, // со всего света собрались! (СОБРАТЬСЯ)
rus_verbs:ИЗГОНЯТЬ{}, // Вино в пакетах изгоняют с рынка (ИЗГОНЯТЬ)
rus_verbs:ВЛЮБИТЬСЯ{}, // влюбился в нее с первого взгляда (ВЛЮБИТЬСЯ)
rus_verbs:РАЗДАВАТЬСЯ{}, // теперь крик раздавался со всех сторон (РАЗДАВАТЬСЯ)
rus_verbs:ПОСМОТРЕТЬ{}, // Посмотрите на это с моей точки зрения (ПОСМОТРЕТЬ С род)
rus_verbs:СХОДИТЬ{}, // принимать участие во всех этих событиях - значит продолжать сходить с ума (СХОДИТЬ С род)
rus_verbs:РУХНУТЬ{}, // В Башкирии микроавтобус рухнул с моста (РУХНУТЬ С)
rus_verbs:УВОЛИТЬ{}, // рекомендовать уволить их с работы (УВОЛИТЬ С)
rus_verbs:КУПИТЬ{}, // еда , купленная с рук (КУПИТЬ С род)
rus_verbs:УБРАТЬ{}, // помочь убрать со стола? (УБРАТЬ С)
rus_verbs:ТЯНУТЬ{}, // с моря тянуло ветром (ТЯНУТЬ С)
rus_verbs:ПРИХОДИТЬ{}, // приходит с работы муж (ПРИХОДИТЬ С)
rus_verbs:ПРОПАСТЬ{}, // изображение пропало с экрана (ПРОПАСТЬ С)
rus_verbs:ПОТЯНУТЬ{}, // с балкона потянуло холодом (ПОТЯНУТЬ С род)
rus_verbs:РАЗДАТЬСЯ{}, // с палубы раздался свист (РАЗДАТЬСЯ С род)
rus_verbs:ЗАЙТИ{}, // зашел с другой стороны (ЗАЙТИ С род)
rus_verbs:НАЧАТЬ{}, // давай начнем с этого (НАЧАТЬ С род)
rus_verbs:УВЕСТИ{}, // дала увести с развалин (УВЕСТИ С род)
rus_verbs:ОПУСКАТЬСЯ{}, // с гор опускалась ночь (ОПУСКАТЬСЯ С)
rus_verbs:ВСКОЧИТЬ{}, // Тристан вскочил с места (ВСКОЧИТЬ С род)
rus_verbs:БРАТЬ{}, // беру с него пример (БРАТЬ С род)
rus_verbs:ПРИПОДНЯТЬСЯ{}, // голова приподнялась с плеча (ПРИПОДНЯТЬСЯ С род)
rus_verbs:ПОЯВИТЬСЯ{}, // всадники появились с востока (ПОЯВИТЬСЯ С род)
rus_verbs:НАЛЕТЕТЬ{}, // с моря налетел ветер (НАЛЕТЕТЬ С род)
rus_verbs:ВЗВИТЬСЯ{}, // Натан взвился с места (ВЗВИТЬСЯ С род)
rus_verbs:ПОДОБРАТЬ{}, // подобрал с земли копье (ПОДОБРАТЬ С)
rus_verbs:ДЕРНУТЬСЯ{}, // Кирилл дернулся с места (ДЕРНУТЬСЯ С род)
rus_verbs:ВОЗВРАЩАТЬСЯ{}, // они возвращались с реки (ВОЗВРАЩАТЬСЯ С род)
rus_verbs:ПЛЫТЬ{}, // плыли они с запада (ПЛЫТЬ С род)
rus_verbs:ЗНАТЬ{}, // одно знали с древности (ЗНАТЬ С)
rus_verbs:НАКЛОНИТЬСЯ{}, // всадник наклонился с лошади (НАКЛОНИТЬСЯ С)
rus_verbs:НАЧАТЬСЯ{}, // началось все со скуки (НАЧАТЬСЯ С)
прилагательное:ИЗВЕСТНЫЙ{}, // Культура его известна со времен глубокой древности (ИЗВЕСТНЫЙ С)
rus_verbs:СБИТЬ{}, // Порыв ветра сбил Ваньку с ног (ts СБИТЬ С)
rus_verbs:СОБИРАТЬСЯ{}, // они собираются сюда со всей равнины. (СОБИРАТЬСЯ С род)
rus_verbs:смыть{}, // Дождь должен смыть с листьев всю пыль. (СМЫТЬ С)
rus_verbs:привстать{}, // Мартин привстал со своего стула. (привстать с)
rus_verbs:спасть{}, // тяжесть спала с души. (спасть с)
rus_verbs:выглядеть{}, // так оно со стороны выглядело. (ВЫГЛЯДЕТЬ С)
rus_verbs:повернуть{}, // к вечеру они повернули с нее направо. (ПОВЕРНУТЬ С)
rus_verbs:ТЯНУТЬСЯ{}, // со стороны реки ко мне тянулись языки тумана. (ТЯНУТЬСЯ С)
rus_verbs:ВОЕВАТЬ{}, // Генерал воевал с юных лет. (ВОЕВАТЬ С чего-то)
rus_verbs:БОЛЕТЬ{}, // Голова болит с похмелья. (БОЛЕТЬ С)
rus_verbs:приближаться{}, // со стороны острова приближалась лодка.
rus_verbs:ПОТЯНУТЬСЯ{}, // со всех сторон к нему потянулись руки. (ПОТЯНУТЬСЯ С)
rus_verbs:пойти{}, // низкий гул пошел со стороны долины. (пошел с)
rus_verbs:зашевелиться{}, // со всех сторон зашевелились кусты. (зашевелиться с)
rus_verbs:МЧАТЬСЯ{}, // со стороны леса мчались всадники. (МЧАТЬСЯ С)
rus_verbs:БЕЖАТЬ{}, // люди бежали со всех ног. (БЕЖАТЬ С)
rus_verbs:СЛЫШАТЬСЯ{}, // шум слышался со стороны моря. (СЛЫШАТЬСЯ С)
rus_verbs:ЛЕТЕТЬ{}, // со стороны деревни летела птица. (ЛЕТЕТЬ С)
rus_verbs:ПЕРЕТЬ{}, // враги прут со всех сторон. (ПЕРЕТЬ С)
rus_verbs:ПОСЫПАТЬСЯ{}, // вопросы посыпались со всех сторон. (ПОСЫПАТЬСЯ С)
rus_verbs:ИДТИ{}, // угроза шла со стороны моря. (ИДТИ С + род.п.)
rus_verbs:ПОСЛЫШАТЬСЯ{}, // со стен послышались крики ужаса. (ПОСЛЫШАТЬСЯ С)
rus_verbs:ОБРУШИТЬСЯ{}, // звуки обрушились со всех сторон. (ОБРУШИТЬСЯ С)
rus_verbs:УДАРИТЬ{}, // голоса ударили со всех сторон. (УДАРИТЬ С)
rus_verbs:ПОКАЗАТЬСЯ{}, // со стороны деревни показались земляне. (ПОКАЗАТЬСЯ С)
rus_verbs:прыгать{}, // придется прыгать со второго этажа. (прыгать с)
rus_verbs:СТОЯТЬ{}, // со всех сторон стоял лес. (СТОЯТЬ С)
rus_verbs:доноситься{}, // шум со двора доносился чудовищный. (доноситься с)
rus_verbs:мешать{}, // мешать воду с мукой (мешать с)
rus_verbs:вестись{}, // Переговоры ведутся с позиции силы. (вестись с)
rus_verbs:вставать{}, // Он не встает с кровати. (вставать с)
rus_verbs:окружать{}, // зеленые щупальца окружали ее со всех сторон. (окружать с)
rus_verbs:причитаться{}, // С вас причитается 50 рублей.
rus_verbs:соскользнуть{}, // его острый клюв соскользнул с ее руки.
rus_verbs:сократить{}, // Его сократили со службы.
rus_verbs:поднять{}, // рука подняла с пола
rus_verbs:поднимать{},
rus_verbs:тащить{}, // тем временем другие пришельцы тащили со всех сторон камни.
rus_verbs:полететь{}, // Мальчик полетел с лестницы.
rus_verbs:литься{}, // вода льется с неба
rus_verbs:натечь{}, // натечь с сапог
rus_verbs:спрыгивать{}, // спрыгивать с движущегося трамвая
rus_verbs:съезжать{}, // съезжать с заявленной темы
rus_verbs:покатываться{}, // покатываться со смеху
rus_verbs:перескакивать{}, // перескакивать с одного примера на другой
rus_verbs:сдирать{}, // сдирать с тела кожу
rus_verbs:соскальзывать{}, // соскальзывать с крючка
rus_verbs:сметать{}, // сметать с прилавков
rus_verbs:кувыркнуться{}, // кувыркнуться со ступеньки
rus_verbs:прокаркать{}, // прокаркать с ветки
rus_verbs:стряхивать{}, // стряхивать с одежды
rus_verbs:сваливаться{}, // сваливаться с лестницы
rus_verbs:слизнуть{}, // слизнуть с лица
rus_verbs:доставляться{}, // доставляться с фермы
rus_verbs:обступать{}, // обступать с двух сторон
rus_verbs:повскакивать{}, // повскакивать с мест
rus_verbs:обозревать{}, // обозревать с вершины
rus_verbs:слинять{}, // слинять с урока
rus_verbs:смывать{}, // смывать с лица
rus_verbs:спихнуть{}, // спихнуть со стола
rus_verbs:обозреть{}, // обозреть с вершины
rus_verbs:накупить{}, // накупить с рук
rus_verbs:схлынуть{}, // схлынуть с берега
rus_verbs:спикировать{}, // спикировать с километровой высоты
rus_verbs:уползти{}, // уползти с поля боя
rus_verbs:сбиваться{}, // сбиваться с пути
rus_verbs:отлучиться{}, // отлучиться с поста
rus_verbs:сигануть{}, // сигануть с крыши
rus_verbs:сместить{}, // сместить с поста
rus_verbs:списать{}, // списать с оригинального устройства
инфинитив:слетать{ вид:несоверш }, глагол:слетать{ вид:несоверш }, // слетать с трассы
деепричастие:слетая{},
rus_verbs:напиваться{}, // напиваться с горя
rus_verbs:свесить{}, // свесить с крыши
rus_verbs:заполучить{}, // заполучить со склада
rus_verbs:спадать{}, // спадать с глаз
rus_verbs:стартовать{}, // стартовать с мыса
rus_verbs:спереть{}, // спереть со склада
rus_verbs:согнать{}, // согнать с живота
rus_verbs:скатываться{}, // скатываться со стога
rus_verbs:сняться{}, // сняться с выборов
rus_verbs:слезать{}, // слезать со стола
rus_verbs:деваться{}, // деваться с подводной лодки
rus_verbs:огласить{}, // огласить с трибуны
rus_verbs:красть{}, // красть со склада
rus_verbs:расширить{}, // расширить с торца
rus_verbs:угадывать{}, // угадывать с полуслова
rus_verbs:оскорбить{}, // оскорбить со сцены
rus_verbs:срывать{}, // срывать с головы
rus_verbs:сшибить{}, // сшибить с коня
rus_verbs:сбивать{}, // сбивать с одежды
rus_verbs:содрать{}, // содрать с посетителей
rus_verbs:столкнуть{}, // столкнуть с горы
rus_verbs:отряхнуть{}, // отряхнуть с одежды
rus_verbs:сбрасывать{}, // сбрасывать с борта
rus_verbs:расстреливать{}, // расстреливать с борта вертолета
rus_verbs:придти{}, // мать скоро придет с работы
rus_verbs:съехать{}, // Миша съехал с горки
rus_verbs:свисать{}, // свисать с веток
rus_verbs:стянуть{}, // стянуть с кровати
rus_verbs:скинуть{}, // скинуть снег с плеча
rus_verbs:загреметь{}, // загреметь со стула
rus_verbs:сыпаться{}, // сыпаться с неба
rus_verbs:стряхнуть{}, // стряхнуть с головы
rus_verbs:сползти{}, // сползти со стула
rus_verbs:стереть{}, // стереть с экрана
rus_verbs:прогнать{}, // прогнать с фермы
rus_verbs:смахнуть{}, // смахнуть со стола
rus_verbs:спускать{}, // спускать с поводка
rus_verbs:деться{}, // деться с подводной лодки
rus_verbs:сдернуть{}, // сдернуть с себя
rus_verbs:сдвинуться{}, // сдвинуться с места
rus_verbs:слететь{}, // слететь с катушек
rus_verbs:обступить{}, // обступить со всех сторон
rus_verbs:снести{}, // снести с плеч
инфинитив:сбегать{ вид:несоверш }, глагол:сбегать{ вид:несоверш }, // сбегать с уроков
деепричастие:сбегая{}, прилагательное:сбегающий{},
// прилагательное:сбегавший{ вид:несоверш },
rus_verbs:запить{}, // запить с горя
rus_verbs:рубануть{}, // рубануть с плеча
rus_verbs:чертыхнуться{}, // чертыхнуться с досады
rus_verbs:срываться{}, // срываться с цепи
rus_verbs:смыться{}, // смыться с уроков
rus_verbs:похитить{}, // похитить со склада
rus_verbs:смести{}, // смести со своего пути
rus_verbs:отгружать{}, // отгружать со склада
rus_verbs:отгрузить{}, // отгрузить со склада
rus_verbs:бросаться{}, // Дети бросались в воду с моста
rus_verbs:броситься{}, // самоубийца бросился с моста в воду
rus_verbs:взимать{}, // Билетер взимает плату с каждого посетителя
rus_verbs:взиматься{}, // Плата взимается с любого посетителя
rus_verbs:взыскать{}, // Приставы взыскали долг с бедолаги
rus_verbs:взыскивать{}, // Приставы взыскивают с бедолаги все долги
rus_verbs:взыскиваться{}, // Долги взыскиваются с алиментщиков
rus_verbs:вспархивать{}, // вспархивать с цветка
rus_verbs:вспорхнуть{}, // вспорхнуть с ветки
rus_verbs:выбросить{}, // выбросить что-то с балкона
rus_verbs:выводить{}, // выводить с одежды пятна
rus_verbs:снять{}, // снять с головы
rus_verbs:начинать{}, // начинать с эскиза
rus_verbs:двинуться{}, // двинуться с места
rus_verbs:начинаться{}, // начинаться с гардероба
rus_verbs:стечь{}, // стечь с крыши
rus_verbs:слезть{}, // слезть с кучи
rus_verbs:спуститься{}, // спуститься с крыши
rus_verbs:сойти{}, // сойти с пьедестала
rus_verbs:свернуть{}, // свернуть с пути
rus_verbs:сорвать{}, // сорвать с цепи
rus_verbs:сорваться{}, // сорваться с поводка
rus_verbs:тронуться{}, // тронуться с места
rus_verbs:угадать{}, // угадать с первой попытки
rus_verbs:спустить{}, // спустить с лестницы
rus_verbs:соскочить{}, // соскочить с крючка
rus_verbs:сдвинуть{}, // сдвинуть с места
rus_verbs:подниматься{}, // туман, поднимающийся с болота
rus_verbs:подняться{}, // туман, поднявшийся с болота
rus_verbs:валить{}, // Резкий порывистый ветер валит прохожих с ног.
rus_verbs:свалить{}, // Резкий порывистый ветер свалит тебя с ног.
rus_verbs:донестись{}, // С улицы донесся шум дождя.
rus_verbs:опасть{}, // Опавшие с дерева листья.
rus_verbs:махнуть{}, // Он махнул с берега в воду.
rus_verbs:исчезнуть{}, // исчезнуть с экрана
rus_verbs:свалиться{}, // свалиться со сцены
rus_verbs:упасть{}, // упасть с дерева
rus_verbs:вернуться{}, // Он ещё не вернулся с работы.
rus_verbs:сдувать{}, // сдувать пух с одуванчиков
rus_verbs:свергать{}, // свергать царя с трона
rus_verbs:сбиться{}, // сбиться с пути
rus_verbs:стирать{}, // стирать тряпкой надпись с доски
rus_verbs:убирать{}, // убирать мусор c пола
rus_verbs:удалять{}, // удалять игрока с поля
rus_verbs:окружить{}, // Япония окружена со всех сторон морями.
rus_verbs:снимать{}, // Я снимаю с себя всякую ответственность за его поведение.
глагол:писаться{ aux stress="пис^аться" }, // Собственные имена пишутся с большой буквы.
прилагательное:спокойный{}, // С этой стороны я спокоен.
rus_verbs:спросить{}, // С тебя за всё спросят.
rus_verbs:течь{}, // С него течёт пот.
rus_verbs:дуть{}, // С моря дует ветер.
rus_verbs:капать{}, // С его лица капали крупные капли пота.
rus_verbs:опустить{}, // Она опустила ребёнка с рук на пол.
rus_verbs:спрыгнуть{}, // Она легко спрыгнула с коня.
rus_verbs:встать{}, // Все встали со стульев.
rus_verbs:сбросить{}, // Войдя в комнату, он сбросил с себя пальто.
rus_verbs:взять{}, // Возьми книгу с полки.
rus_verbs:спускаться{}, // Мы спускались с горы.
rus_verbs:уйти{}, // Он нашёл себе заместителя и ушёл со службы.
rus_verbs:порхать{}, // Бабочка порхает с цветка на цветок.
rus_verbs:отправляться{}, // Ваш поезд отправляется со второй платформы.
rus_verbs:двигаться{}, // Он не двигался с места.
rus_verbs:отходить{}, // мой поезд отходит с первого пути
rus_verbs:попасть{}, // Майкл попал в кольцо с десятиметровой дистанции
rus_verbs:падать{}, // снег падает с ветвей
rus_verbs:скрыться{} // Ее водитель, бросив машину, скрылся с места происшествия.
}
fact гл_предл
{
if context { Гл_С_Род предлог:с{} @regex("[a-z]+[0-9]*") }
then return true
}
fact гл_предл
{
if context { Гл_С_Род предлог:с{} *:*{падеж:род} }
then return true
}
fact гл_предл
{
if context { Гл_С_Род предлог:с{} *:*{падеж:парт} }
then return true
}
#endregion РОДИТЕЛЬНЫЙ
fact гл_предл
{
if context { * предлог:с{} *:*{ падеж:твор } }
then return false,-3
}
fact гл_предл
{
if context { * предлог:с{} *:*{ падеж:род } }
then return false,-4
}
fact гл_предл
{
if context { * предлог:с{} * }
then return false,-5
}
#endregion Предлог_С
/*
#region Предлог_ПОД
// -------------- ПРЕДЛОГ 'ПОД' -----------------------
fact гл_предл
{
if context { * предлог:под{} @regex("[a-z]+[0-9]*") }
then return true
}
// ПОД+вин.п. не может присоединяться к существительным, поэтому
// он присоединяется к любым глаголам.
fact гл_предл
{
if context { * предлог:под{} *:*{ падеж:вин } }
then return true
}
wordentry_set Гл_ПОД_твор=
{
rus_verbs:извиваться{}, // извивалась под его длинными усами
rus_verbs:РАСПРОСТРАНЯТЬСЯ{}, // Под густым ковром травы и плотным сплетением корней (РАСПРОСТРАНЯТЬСЯ)
rus_verbs:БРОСИТЬ{}, // чтобы ты его под деревом бросил? (БРОСИТЬ)
rus_verbs:БИТЬСЯ{}, // под моей щекой сильно билось его сердце (БИТЬСЯ)
rus_verbs:ОПУСТИТЬСЯ{}, // глаза его опустились под ее желтым взглядом (ОПУСТИТЬСЯ)
rus_verbs:ВЗДЫМАТЬСЯ{}, // его грудь судорожно вздымалась под ее рукой (ВЗДЫМАТЬСЯ)
rus_verbs:ПРОМЧАТЬСЯ{}, // Она промчалась под ними и исчезла за изгибом горы. (ПРОМЧАТЬСЯ)
rus_verbs:всплыть{}, // Наконец он всплыл под нависавшей кормой, так и не отыскав того, что хотел. (всплыть)
rus_verbs:КОНЧАТЬСЯ{}, // Он почти вертикально уходит в реку и кончается глубоко под водой. (КОНЧАТЬСЯ)
rus_verbs:ПОЛЗТИ{}, // Там они ползли под спутанным терновником и сквозь переплетавшиеся кусты (ПОЛЗТИ)
rus_verbs:ПРОХОДИТЬ{}, // Вольф проходил под гигантскими ветвями деревьев и мхов, свисавших с ветвей зелеными водопадами. (ПРОХОДИТЬ, ПРОПОЛЗТИ, ПРОПОЛЗАТЬ)
rus_verbs:ПРОПОЛЗТИ{}, //
rus_verbs:ПРОПОЛЗАТЬ{}, //
rus_verbs:ИМЕТЬ{}, // Эти предположения не имеют под собой никакой почвы (ИМЕТЬ)
rus_verbs:НОСИТЬ{}, // она носит под сердцем ребенка (НОСИТЬ)
rus_verbs:ПАСТЬ{}, // Рим пал под натиском варваров (ПАСТЬ)
rus_verbs:УТОНУТЬ{}, // Выступавшие старческие вены снова утонули под гладкой твердой плотью. (УТОНУТЬ)
rus_verbs:ВАЛЯТЬСЯ{}, // Под его кривыми серыми ветвями и пестрыми коричнево-зелеными листьями валялись пустые ореховые скорлупки и сердцевины плодов. (ВАЛЯТЬСЯ)
rus_verbs:вздрогнуть{}, // она вздрогнула под его взглядом
rus_verbs:иметься{}, // у каждого под рукой имелся арбалет
rus_verbs:ЖДАТЬ{}, // Сашка уже ждал под дождем (ЖДАТЬ)
rus_verbs:НОЧЕВАТЬ{}, // мне приходилось ночевать под открытым небом (НОЧЕВАТЬ)
rus_verbs:УЗНАТЬ{}, // вы должны узнать меня под этим именем (УЗНАТЬ)
rus_verbs:ЗАДЕРЖИВАТЬСЯ{}, // мне нельзя задерживаться под землей! (ЗАДЕРЖИВАТЬСЯ)
rus_verbs:ПОГИБНУТЬ{}, // под их копытами погибли целые армии! (ПОГИБНУТЬ)
rus_verbs:РАЗДАВАТЬСЯ{}, // под ногами у меня раздавался сухой хруст (РАЗДАВАТЬСЯ)
rus_verbs:КРУЖИТЬСЯ{}, // поверхность планеты кружилась у него под ногами (КРУЖИТЬСЯ)
rus_verbs:ВИСЕТЬ{}, // под глазами у него висели тяжелые складки кожи (ВИСЕТЬ)
rus_verbs:содрогнуться{}, // содрогнулся под ногами каменный пол (СОДРОГНУТЬСЯ)
rus_verbs:СОБИРАТЬСЯ{}, // темнота уже собиралась под деревьями (СОБИРАТЬСЯ)
rus_verbs:УПАСТЬ{}, // толстяк упал под градом ударов (УПАСТЬ)
rus_verbs:ДВИНУТЬСЯ{}, // лодка двинулась под водой (ДВИНУТЬСЯ)
rus_verbs:ЦАРИТЬ{}, // под его крышей царила холодная зима (ЦАРИТЬ)
rus_verbs:ПРОВАЛИТЬСЯ{}, // под копытами его лошади провалился мост (ПРОВАЛИТЬСЯ ПОД твор)
rus_verbs:ЗАДРОЖАТЬ{}, // земля задрожала под ногами (ЗАДРОЖАТЬ)
rus_verbs:НАХМУРИТЬСЯ{}, // государь нахмурился под маской (НАХМУРИТЬСЯ)
rus_verbs:РАБОТАТЬ{}, // работать под угрозой нельзя (РАБОТАТЬ)
rus_verbs:ШЕВЕЛЬНУТЬСЯ{}, // под ногой шевельнулся камень (ШЕВЕЛЬНУТЬСЯ)
rus_verbs:ВИДЕТЬ{}, // видел тебя под камнем. (ВИДЕТЬ)
rus_verbs:ОСТАТЬСЯ{}, // второе осталось под водой (ОСТАТЬСЯ)
rus_verbs:КИПЕТЬ{}, // вода кипела под копытами (КИПЕТЬ)
rus_verbs:СИДЕТЬ{}, // может сидит под деревом (СИДЕТЬ)
rus_verbs:МЕЛЬКНУТЬ{}, // под нами мелькнуло море (МЕЛЬКНУТЬ)
rus_verbs:ПОСЛЫШАТЬСЯ{}, // под окном послышался шум (ПОСЛЫШАТЬСЯ)
rus_verbs:ТЯНУТЬСЯ{}, // под нами тянулись облака (ТЯНУТЬСЯ)
rus_verbs:ДРОЖАТЬ{}, // земля дрожала под ним (ДРОЖАТЬ)
rus_verbs:ПРИЙТИСЬ{}, // хуже пришлось под землей (ПРИЙТИСЬ)
rus_verbs:ГОРЕТЬ{}, // лампа горела под потолком (ГОРЕТЬ)
rus_verbs:ПОЛОЖИТЬ{}, // положил под деревом плащ (ПОЛОЖИТЬ)
rus_verbs:ЗАГОРЕТЬСЯ{}, // под деревьями загорелся костер (ЗАГОРЕТЬСЯ)
rus_verbs:ПРОНОСИТЬСЯ{}, // под нами проносились крыши (ПРОНОСИТЬСЯ)
rus_verbs:ПОТЯНУТЬСЯ{}, // под кораблем потянулись горы (ПОТЯНУТЬСЯ)
rus_verbs:БЕЖАТЬ{}, // беги под серой стеной ночи (БЕЖАТЬ)
rus_verbs:РАЗДАТЬСЯ{}, // под окном раздалось тяжелое дыхание (РАЗДАТЬСЯ)
rus_verbs:ВСПЫХНУТЬ{}, // под потолком вспыхнула яркая лампа (ВСПЫХНУТЬ)
rus_verbs:СМОТРЕТЬ{}, // просто смотрите под другим углом (СМОТРЕТЬ ПОД)
rus_verbs:ДУТЬ{}, // теперь под деревьями дул ветерок (ДУТЬ)
rus_verbs:СКРЫТЬСЯ{}, // оно быстро скрылось под водой (СКРЫТЬСЯ ПОД)
rus_verbs:ЩЕЛКНУТЬ{}, // далеко под ними щелкнул выстрел (ЩЕЛКНУТЬ)
rus_verbs:ТРЕЩАТЬ{}, // осколки стекла трещали под ногами (ТРЕЩАТЬ)
rus_verbs:РАСПОЛАГАТЬСЯ{}, // под ними располагались разноцветные скамьи (РАСПОЛАГАТЬСЯ)
rus_verbs:ВЫСТУПИТЬ{}, // под ногтями выступили капельки крови (ВЫСТУПИТЬ)
rus_verbs:НАСТУПИТЬ{}, // под куполом базы наступила тишина (НАСТУПИТЬ)
rus_verbs:ОСТАНОВИТЬСЯ{}, // повозка остановилась под самым окном (ОСТАНОВИТЬСЯ)
rus_verbs:РАСТАЯТЬ{}, // магазин растаял под ночным дождем (РАСТАЯТЬ)
rus_verbs:ДВИГАТЬСЯ{}, // под водой двигалось нечто огромное (ДВИГАТЬСЯ)
rus_verbs:БЫТЬ{}, // под снегом могут быть трещины (БЫТЬ)
rus_verbs:ЗИЯТЬ{}, // под ней зияла ужасная рана (ЗИЯТЬ)
rus_verbs:ЗАЗВОНИТЬ{}, // под рукой водителя зазвонил телефон (ЗАЗВОНИТЬ)
rus_verbs:ПОКАЗАТЬСЯ{}, // внезапно под ними показалась вода (ПОКАЗАТЬСЯ)
rus_verbs:ЗАМЕРЕТЬ{}, // эхо замерло под высоким потолком (ЗАМЕРЕТЬ)
rus_verbs:ПОЙТИ{}, // затем под кораблем пошла пустыня (ПОЙТИ)
rus_verbs:ДЕЙСТВОВАТЬ{}, // боги всегда действуют под маской (ДЕЙСТВОВАТЬ)
rus_verbs:БЛЕСТЕТЬ{}, // мокрый мех блестел под луной (БЛЕСТЕТЬ)
rus_verbs:ЛЕТЕТЬ{}, // под ним летела серая земля (ЛЕТЕТЬ)
rus_verbs:СОГНУТЬСЯ{}, // содрогнулся под ногами каменный пол (СОГНУТЬСЯ)
rus_verbs:КИВНУТЬ{}, // четвертый слегка кивнул под капюшоном (КИВНУТЬ)
rus_verbs:УМЕРЕТЬ{}, // колдун умер под грудой каменных глыб (УМЕРЕТЬ)
rus_verbs:ОКАЗЫВАТЬСЯ{}, // внезапно под ногами оказывается знакомая тропинка (ОКАЗЫВАТЬСЯ)
rus_verbs:ИСЧЕЗАТЬ{}, // серая лента дороги исчезала под воротами (ИСЧЕЗАТЬ)
rus_verbs:СВЕРКНУТЬ{}, // голубые глаза сверкнули под густыми бровями (СВЕРКНУТЬ)
rus_verbs:СИЯТЬ{}, // под ним сияла белая пелена облаков (СИЯТЬ)
rus_verbs:ПРОНЕСТИСЬ{}, // тихий смех пронесся под куполом зала (ПРОНЕСТИСЬ)
rus_verbs:СКОЛЬЗИТЬ{}, // обломки судна медленно скользили под ними (СКОЛЬЗИТЬ)
rus_verbs:ВЗДУТЬСЯ{}, // под серой кожей вздулись шары мускулов (ВЗДУТЬСЯ)
rus_verbs:ПРОЙТИ{}, // обломок отлично пройдет под колесами слева (ПРОЙТИ)
rus_verbs:РАЗВЕВАТЬСЯ{}, // светлые волосы развевались под дыханием ветра (РАЗВЕВАТЬСЯ)
rus_verbs:СВЕРКАТЬ{}, // глаза огнем сверкали под темными бровями (СВЕРКАТЬ)
rus_verbs:КАЗАТЬСЯ{}, // деревянный док казался очень твердым под моими ногами (КАЗАТЬСЯ)
rus_verbs:ПОСТАВИТЬ{}, // четвертый маг торопливо поставил под зеркалом широкую чашу (ПОСТАВИТЬ)
rus_verbs:ОСТАВАТЬСЯ{}, // запасы остаются под давлением (ОСТАВАТЬСЯ ПОД)
rus_verbs:ПЕТЬ{}, // просто мы под землей любим петь. (ПЕТЬ ПОД)
rus_verbs:ПОЯВИТЬСЯ{}, // под их крыльями внезапно появился дым. (ПОЯВИТЬСЯ ПОД)
rus_verbs:ОКАЗАТЬСЯ{}, // мы снова оказались под солнцем. (ОКАЗАТЬСЯ ПОД)
rus_verbs:ПОДХОДИТЬ{}, // мы подходили под другим углом? (ПОДХОДИТЬ ПОД)
rus_verbs:СКРЫВАТЬСЯ{}, // кто под ней скрывается? (СКРЫВАТЬСЯ ПОД)
rus_verbs:ХЛЮПАТЬ{}, // под ногами Аллы хлюпала грязь (ХЛЮПАТЬ ПОД)
rus_verbs:ШАГАТЬ{}, // их отряд весело шагал под дождем этой музыки. (ШАГАТЬ ПОД)
rus_verbs:ТЕЧЬ{}, // под ее поверхностью медленно текла ярость. (ТЕЧЬ ПОД твор)
rus_verbs:ОЧУТИТЬСЯ{}, // мы очутились под стенами замка. (ОЧУТИТЬСЯ ПОД)
rus_verbs:ПОБЛЕСКИВАТЬ{}, // их латы поблескивали под солнцем. (ПОБЛЕСКИВАТЬ ПОД)
rus_verbs:ДРАТЬСЯ{}, // под столами дрались за кости псы. (ДРАТЬСЯ ПОД)
rus_verbs:КАЧНУТЬСЯ{}, // палуба качнулась у нас под ногами. (КАЧНУЛАСЬ ПОД)
rus_verbs:ПРИСЕСТЬ{}, // конь даже присел под тяжелым телом. (ПРИСЕСТЬ ПОД)
rus_verbs:ЖИТЬ{}, // они живут под землей. (ЖИТЬ ПОД)
rus_verbs:ОБНАРУЖИТЬ{}, // вы можете обнаружить ее под водой? (ОБНАРУЖИТЬ ПОД)
rus_verbs:ПЛЫТЬ{}, // Орёл плывёт под облаками. (ПЛЫТЬ ПОД)
rus_verbs:ИСЧЕЗНУТЬ{}, // потом они исчезли под водой. (ИСЧЕЗНУТЬ ПОД)
rus_verbs:держать{}, // оружие все держали под рукой. (держать ПОД)
rus_verbs:ВСТРЕТИТЬСЯ{}, // они встретились под водой. (ВСТРЕТИТЬСЯ ПОД)
rus_verbs:уснуть{}, // Миша уснет под одеялом
rus_verbs:пошевелиться{}, // пошевелиться под одеялом
rus_verbs:задохнуться{}, // задохнуться под слоем снега
rus_verbs:потечь{}, // потечь под избыточным давлением
rus_verbs:уцелеть{}, // уцелеть под завалами
rus_verbs:мерцать{}, // мерцать под лучами софитов
rus_verbs:поискать{}, // поискать под кроватью
rus_verbs:гудеть{}, // гудеть под нагрузкой
rus_verbs:посидеть{}, // посидеть под навесом
rus_verbs:укрыться{}, // укрыться под навесом
rus_verbs:утихнуть{}, // утихнуть под одеялом
rus_verbs:заскрипеть{}, // заскрипеть под тяжестью
rus_verbs:шелохнуться{}, // шелохнуться под одеялом
инфинитив:срезать{ вид:несоверш }, глагол:срезать{ вид:несоверш }, // срезать под корень
деепричастие:срезав{}, прилагательное:срезающий{ вид:несоверш },
инфинитив:срезать{ вид:соверш }, глагол:срезать{ вид:соверш },
деепричастие:срезая{}, прилагательное:срезавший{ вид:соверш },
rus_verbs:пониматься{}, // пониматься под успехом
rus_verbs:подразумеваться{}, // подразумеваться под правильным решением
rus_verbs:промокнуть{}, // промокнуть под проливным дождем
rus_verbs:засосать{}, // засосать под ложечкой
rus_verbs:подписаться{}, // подписаться под воззванием
rus_verbs:укрываться{}, // укрываться под навесом
rus_verbs:запыхтеть{}, // запыхтеть под одеялом
rus_verbs:мокнуть{}, // мокнуть под лождем
rus_verbs:сгибаться{}, // сгибаться под тяжестью снега
rus_verbs:намокнуть{}, // намокнуть под дождем
rus_verbs:подписываться{}, // подписываться под обращением
rus_verbs:тарахтеть{}, // тарахтеть под окнами
инфинитив:находиться{вид:несоверш}, глагол:находиться{вид:несоверш}, // Она уже несколько лет находится под наблюдением врача.
деепричастие:находясь{}, прилагательное:находившийся{вид:несоверш}, прилагательное:находящийся{},
rus_verbs:лежать{}, // лежать под капельницей
rus_verbs:вымокать{}, // вымокать под дождём
rus_verbs:вымокнуть{}, // вымокнуть под дождём
rus_verbs:проворчать{}, // проворчать под нос
rus_verbs:хмыкнуть{}, // хмыкнуть под нос
rus_verbs:отыскать{}, // отыскать под кроватью
rus_verbs:дрогнуть{}, // дрогнуть под ударами
rus_verbs:проявляться{}, // проявляться под нагрузкой
rus_verbs:сдержать{}, // сдержать под контролем
rus_verbs:ложиться{}, // ложиться под клиента
rus_verbs:таять{}, // таять под весенним солнцем
rus_verbs:покатиться{}, // покатиться под откос
rus_verbs:лечь{}, // он лег под навесом
rus_verbs:идти{}, // идти под дождем
прилагательное:известный{}, // Он известен под этим именем.
rus_verbs:стоять{}, // Ящик стоит под столом.
rus_verbs:отступить{}, // Враг отступил под ударами наших войск.
rus_verbs:царапаться{}, // Мышь царапается под полом.
rus_verbs:спать{}, // заяц спокойно спал у себя под кустом
rus_verbs:загорать{}, // мы загораем под солнцем
ГЛ_ИНФ(мыть), // мыть руки под струёй воды
ГЛ_ИНФ(закопать),
ГЛ_ИНФ(спрятать),
ГЛ_ИНФ(прятать),
ГЛ_ИНФ(перепрятать)
}
fact гл_предл
{
if context { Гл_ПОД_твор предлог:под{} *:*{ падеж:твор } }
then return true
}
// для глаголов вне списка - запрещаем.
fact гл_предл
{
if context { * предлог:под{} *:*{ падеж:твор } }
then return false,-10
}
fact гл_предл
{
if context { * предлог:под{} *:*{} }
then return false,-11
}
#endregion Предлог_ПОД
*/
#region Предлог_ОБ
// -------------- ПРЕДЛОГ 'ОБ' -----------------------
wordentry_set Гл_ОБ_предл=
{
rus_verbs:СВИДЕТЕЛЬСТВОВАТЬ{}, // Об их присутствии свидетельствовало лишь тусклое пурпурное пятно, проступавшее на камне. (СВИДЕТЕЛЬСТВОВАТЬ)
rus_verbs:ЗАДУМАТЬСЯ{}, // Промышленные гиганты задумались об экологии (ЗАДУМАТЬСЯ)
rus_verbs:СПРОСИТЬ{}, // Он спросил нескольких из пляжников об их кажущейся всеобщей юности. (СПРОСИТЬ)
rus_verbs:спрашивать{}, // как ты можешь еще спрашивать у меня об этом?
rus_verbs:забывать{}, // Мы не можем забывать об их участи.
rus_verbs:ГАДАТЬ{}, // теперь об этом можно лишь гадать (ГАДАТЬ)
rus_verbs:ПОВЕДАТЬ{}, // Градоначальник , выступая с обзором основных городских событий , поведал об этом депутатам (ПОВЕДАТЬ ОБ)
rus_verbs:СООБЩИТЬ{}, // Иран сообщил МАГАТЭ об ускорении обогащения урана (СООБЩИТЬ)
rus_verbs:ЗАЯВИТЬ{}, // Об их успешном окончании заявил генеральный директор (ЗАЯВИТЬ ОБ)
rus_verbs:слышать{}, // даже они слышали об этом человеке. (СЛЫШАТЬ ОБ)
rus_verbs:ДОЛОЖИТЬ{}, // вернувшиеся разведчики доложили об увиденном (ДОЛОЖИТЬ ОБ)
rus_verbs:ПОГОВОРИТЬ{}, // давай поговорим об этом. (ПОГОВОРИТЬ ОБ)
rus_verbs:ДОГАДАТЬСЯ{}, // об остальном нетрудно догадаться. (ДОГАДАТЬСЯ ОБ)
rus_verbs:ПОЗАБОТИТЬСЯ{}, // обещал обо всем позаботиться. (ПОЗАБОТИТЬСЯ ОБ)
rus_verbs:ПОЗАБЫТЬ{}, // Шура позабыл обо всем. (ПОЗАБЫТЬ ОБ)
rus_verbs:вспоминать{}, // Впоследствии он не раз вспоминал об этом приключении. (вспоминать об)
rus_verbs:сообщать{}, // Газета сообщает об открытии сессии парламента. (сообщать об)
rus_verbs:просить{}, // мы просили об отсрочке платежей (просить ОБ)
rus_verbs:ПЕТЬ{}, // эта же девушка пела обо всем совершенно открыто. (ПЕТЬ ОБ)
rus_verbs:сказать{}, // ты скажешь об этом капитану? (сказать ОБ)
rus_verbs:знать{}, // бы хотелось знать как можно больше об этом районе.
rus_verbs:кричать{}, // Все газеты кричат об этом событии.
rus_verbs:советоваться{}, // Она обо всём советуется с матерью.
rus_verbs:говориться{}, // об остальном говорилось легко.
rus_verbs:подумать{}, // нужно крепко обо всем подумать.
rus_verbs:напомнить{}, // черный дым напомнил об опасности.
rus_verbs:забыть{}, // забудь об этой роскоши.
rus_verbs:думать{}, // приходится обо всем думать самой.
rus_verbs:отрапортовать{}, // отрапортовать об успехах
rus_verbs:информировать{}, // информировать об изменениях
rus_verbs:оповестить{}, // оповестить об отказе
rus_verbs:убиваться{}, // убиваться об стену
rus_verbs:расшибить{}, // расшибить об стену
rus_verbs:заговорить{}, // заговорить об оплате
rus_verbs:отозваться{}, // Он отозвался об этой книге с большой похвалой.
rus_verbs:попросить{}, // попросить об услуге
rus_verbs:объявить{}, // объявить об отставке
rus_verbs:предупредить{}, // предупредить об аварии
rus_verbs:предупреждать{}, // предупреждать об опасности
rus_verbs:твердить{}, // твердить об обязанностях
rus_verbs:заявлять{}, // заявлять об экспериментальном подтверждении
rus_verbs:рассуждать{}, // рассуждать об абстрактных идеях
rus_verbs:говорить{}, // Не говорите об этом в присутствии третьих лиц.
rus_verbs:читать{}, // он читал об этом в журнале
rus_verbs:прочитать{}, // он читал об этом в учебнике
rus_verbs:узнать{}, // он узнал об этом из фильмов
rus_verbs:рассказать{}, // рассказать об экзаменах
rus_verbs:рассказывать{},
rus_verbs:договориться{}, // договориться об оплате
rus_verbs:договариваться{}, // договариваться об обмене
rus_verbs:болтать{}, // Не болтай об этом!
rus_verbs:проболтаться{}, // Не проболтайся об этом!
rus_verbs:заботиться{}, // кто заботится об урегулировании
rus_verbs:беспокоиться{}, // вы беспокоитесь об обороне
rus_verbs:помнить{}, // всем советую об этом помнить
rus_verbs:мечтать{} // Мечтать об успехе
}
fact гл_предл
{
if context { Гл_ОБ_предл предлог:об{} *:*{ падеж:предл } }
then return true
}
fact гл_предл
{
if context { * предлог:о{} @regex("[a-z]+[0-9]*") }
then return true
}
fact гл_предл
{
if context { * предлог:об{} @regex("[a-z]+[0-9]*") }
then return true
}
// остальные глаголы не могут связываться
fact гл_предл
{
if context { * предлог:об{} *:*{ падеж:предл } }
then return false, -4
}
wordentry_set Гл_ОБ_вин=
{
rus_verbs:СЛОМАТЬ{}, // потом об колено сломал (СЛОМАТЬ)
rus_verbs:разбить{}, // ты разбил щеку об угол ящика. (РАЗБИТЬ ОБ)
rus_verbs:опереться{}, // Он опёрся об стену.
rus_verbs:опираться{},
rus_verbs:постучать{}, // постучал лбом об пол.
rus_verbs:удариться{}, // бутылка глухо ударилась об землю.
rus_verbs:убиваться{}, // убиваться об стену
rus_verbs:расшибить{}, // расшибить об стену
rus_verbs:царапаться{} // Днище лодки царапалось обо что-то.
}
fact гл_предл
{
if context { Гл_ОБ_вин предлог:об{} *:*{ падеж:вин } }
then return true
}
fact гл_предл
{
if context { * предлог:об{} *:*{ падеж:вин } }
then return false,-4
}
fact гл_предл
{
if context { * предлог:об{} *:*{} }
then return false,-5
}
#endregion Предлог_ОБ
#region Предлог_О
// ------------------- С ПРЕДЛОГОМ 'О' ----------------------
wordentry_set Гл_О_Вин={
rus_verbs:шмякнуть{}, // Ей хотелось шмякнуть ими о стену.
rus_verbs:болтать{}, // Болтали чаще всего о пустяках.
rus_verbs:шваркнуть{}, // Она шваркнула трубкой о рычаг.
rus_verbs:опираться{}, // Мать приподнялась, с трудом опираясь о стол.
rus_verbs:бахнуться{}, // Бахнуться головой о стол.
rus_verbs:ВЫТЕРЕТЬ{}, // Вытащи нож и вытри его о траву. (ВЫТЕРЕТЬ/ВЫТИРАТЬ)
rus_verbs:ВЫТИРАТЬ{}, //
rus_verbs:РАЗБИТЬСЯ{}, // Прибой накатился и с шумом разбился о белый песок. (РАЗБИТЬСЯ)
rus_verbs:СТУКНУТЬ{}, // Сердце его глухо стукнуло о грудную кость (СТУКНУТЬ)
rus_verbs:ЛЯЗГНУТЬ{}, // Он кинулся наземь, покатился, и копье лязгнуло о стену. (ЛЯЗГНУТЬ/ЛЯЗГАТЬ)
rus_verbs:ЛЯЗГАТЬ{}, //
rus_verbs:звенеть{}, // стрелы уже звенели о прутья клетки
rus_verbs:ЩЕЛКНУТЬ{}, // камень щелкнул о скалу (ЩЕЛКНУТЬ)
rus_verbs:БИТЬ{}, // волна бьет о берег (БИТЬ)
rus_verbs:ЗАЗВЕНЕТЬ{}, // зазвенели мечи о щиты (ЗАЗВЕНЕТЬ)
rus_verbs:колотиться{}, // сердце его колотилось о ребра
rus_verbs:стучать{}, // глухо стучали о щиты рукояти мечей.
rus_verbs:биться{}, // биться головой о стену? (биться о)
rus_verbs:ударить{}, // вода ударила его о стену коридора. (ударила о)
rus_verbs:разбиваться{}, // волны разбивались о скалу
rus_verbs:разбивать{}, // Разбивает голову о прутья клетки.
rus_verbs:облокотиться{}, // облокотиться о стену
rus_verbs:точить{}, // точить о точильный камень
rus_verbs:спотыкаться{}, // спотыкаться о спрятавшийся в траве пень
rus_verbs:потереться{}, // потереться о дерево
rus_verbs:ушибиться{}, // ушибиться о дерево
rus_verbs:тереться{}, // тереться о ствол
rus_verbs:шмякнуться{}, // шмякнуться о землю
rus_verbs:убиваться{}, // убиваться об стену
rus_verbs:расшибить{}, // расшибить об стену
rus_verbs:тереть{}, // тереть о камень
rus_verbs:потереть{}, // потереть о колено
rus_verbs:удариться{}, // удариться о край
rus_verbs:споткнуться{}, // споткнуться о камень
rus_verbs:запнуться{}, // запнуться о камень
rus_verbs:запинаться{}, // запинаться о камни
rus_verbs:ударяться{}, // ударяться о бортик
rus_verbs:стукнуться{}, // стукнуться о бортик
rus_verbs:стукаться{}, // стукаться о бортик
rus_verbs:опереться{}, // Он опёрся локтями о стол.
rus_verbs:плескаться{} // Вода плещется о берег.
}
fact гл_предл
{
if context { Гл_О_Вин предлог:о{} *:*{ падеж:вин } }
then return true
}
fact гл_предл
{
if context { * предлог:о{} *:*{ падеж:вин } }
then return false,-5
}
wordentry_set Гл_О_предл={
rus_verbs:КРИЧАТЬ{}, // она кричала о смерти! (КРИЧАТЬ)
rus_verbs:РАССПРОСИТЬ{}, // Я расспросил о нем нескольких горожан. (РАССПРОСИТЬ/РАССПРАШИВАТЬ)
rus_verbs:РАССПРАШИВАТЬ{}, //
rus_verbs:слушать{}, // ты будешь слушать о них?
rus_verbs:вспоминать{}, // вспоминать о том разговоре ему было неприятно
rus_verbs:МОЛЧАТЬ{}, // О чём молчат девушки (МОЛЧАТЬ)
rus_verbs:ПЛАКАТЬ{}, // она плакала о себе (ПЛАКАТЬ)
rus_verbs:сложить{}, // о вас сложены легенды
rus_verbs:ВОЛНОВАТЬСЯ{}, // Я волнуюсь о том, что что-то серьёзно пошло не так (ВОЛНОВАТЬСЯ О)
rus_verbs:УПОМЯНУТЬ{}, // упомянул о намерении команды приобрести несколько новых футболистов (УПОМЯНУТЬ О)
rus_verbs:ОТЧИТЫВАТЬСЯ{}, // Судебные приставы продолжают отчитываться о борьбе с неплательщиками (ОТЧИТЫВАТЬСЯ О)
rus_verbs:ДОЛОЖИТЬ{}, // провести тщательное расследование взрыва в маршрутном такси во Владикавказе и доложить о результатах (ДОЛОЖИТЬ О)
rus_verbs:ПРОБОЛТАТЬ{}, // правительство страны больше проболтало о военной реформе (ПРОБОЛТАТЬ О)
rus_verbs:ЗАБОТИТЬСЯ{}, // Четверть россиян заботятся о здоровье путем просмотра телевизора (ЗАБОТИТЬСЯ О)
rus_verbs:ИРОНИЗИРОВАТЬ{}, // Вы иронизируете о ностальгии по тем временем (ИРОНИЗИРОВАТЬ О)
rus_verbs:СИГНАЛИЗИРОВАТЬ{}, // Кризис цен на продукты питания сигнализирует о неминуемой гиперинфляции (СИГНАЛИЗИРОВАТЬ О)
rus_verbs:СПРОСИТЬ{}, // Он спросил о моём здоровье. (СПРОСИТЬ О)
rus_verbs:НАПОМНИТЬ{}, // больной зуб опять напомнил о себе. (НАПОМНИТЬ О)
rus_verbs:осведомиться{}, // офицер осведомился о цели визита
rus_verbs:объявить{}, // В газете объявили о конкурсе. (объявить о)
rus_verbs:ПРЕДСТОЯТЬ{}, // о чем предстоит разговор? (ПРЕДСТОЯТЬ О)
rus_verbs:объявлять{}, // объявлять о всеобщей забастовке (объявлять о)
rus_verbs:зайти{}, // Разговор зашёл о политике.
rus_verbs:порассказать{}, // порассказать о своих путешествиях
инфинитив:спеть{ вид:соверш }, глагол:спеть{ вид:соверш }, // спеть о неразделенной любви
деепричастие:спев{}, прилагательное:спевший{ вид:соверш },
прилагательное:спетый{},
rus_verbs:напеть{},
rus_verbs:разговаривать{}, // разговаривать с другом о жизни
rus_verbs:рассуждать{}, // рассуждать об абстрактных идеях
//rus_verbs:заботиться{}, // заботиться о престарелых родителях
rus_verbs:раздумывать{}, // раздумывать о новой работе
rus_verbs:договариваться{}, // договариваться о сумме компенсации
rus_verbs:молить{}, // молить о пощаде
rus_verbs:отзываться{}, // отзываться о книге
rus_verbs:подумывать{}, // подумывать о новом подходе
rus_verbs:поговаривать{}, // поговаривать о загадочном звере
rus_verbs:обмолвиться{}, // обмолвиться о проклятии
rus_verbs:условиться{}, // условиться о поддержке
rus_verbs:призадуматься{}, // призадуматься о последствиях
rus_verbs:известить{}, // известить о поступлении
rus_verbs:отрапортовать{}, // отрапортовать об успехах
rus_verbs:напевать{}, // напевать о любви
rus_verbs:помышлять{}, // помышлять о новом деле
rus_verbs:переговорить{}, // переговорить о правилах
rus_verbs:повествовать{}, // повествовать о событиях
rus_verbs:слыхивать{}, // слыхивать о чудище
rus_verbs:потолковать{}, // потолковать о планах
rus_verbs:проговориться{}, // проговориться о планах
rus_verbs:умолчать{}, // умолчать о штрафах
rus_verbs:хлопотать{}, // хлопотать о премии
rus_verbs:уведомить{}, // уведомить о поступлении
rus_verbs:горевать{}, // горевать о потере
rus_verbs:запамятовать{}, // запамятовать о важном мероприятии
rus_verbs:заикнуться{}, // заикнуться о прибавке
rus_verbs:информировать{}, // информировать о событиях
rus_verbs:проболтаться{}, // проболтаться о кладе
rus_verbs:поразмыслить{}, // поразмыслить о судьбе
rus_verbs:заикаться{}, // заикаться о деньгах
rus_verbs:оповестить{}, // оповестить об отказе
rus_verbs:печься{}, // печься о всеобщем благе
rus_verbs:разглагольствовать{}, // разглагольствовать о правах
rus_verbs:размечтаться{}, // размечтаться о будущем
rus_verbs:лепетать{}, // лепетать о невиновности
rus_verbs:грезить{}, // грезить о большой и чистой любви
rus_verbs:залепетать{}, // залепетать о сокровищах
rus_verbs:пронюхать{}, // пронюхать о бесплатной одежде
rus_verbs:протрубить{}, // протрубить о победе
rus_verbs:извещать{}, // извещать о поступлении
rus_verbs:трубить{}, // трубить о поимке разбойников
rus_verbs:осведомляться{}, // осведомляться о судьбе
rus_verbs:поразмышлять{}, // поразмышлять о неизбежном
rus_verbs:слагать{}, // слагать о подвигах викингов
rus_verbs:ходатайствовать{}, // ходатайствовать о выделении материальной помощи
rus_verbs:побеспокоиться{}, // побеспокоиться о правильном стимулировании
rus_verbs:закидывать{}, // закидывать сообщениями об ошибках
rus_verbs:базарить{}, // пацаны базарили о телках
rus_verbs:балагурить{}, // мужики балагурили о новом председателе
rus_verbs:балакать{}, // мужики балакали о новом председателе
rus_verbs:беспокоиться{}, // Она беспокоится о детях
rus_verbs:рассказать{}, // Кумир рассказал о криминале в Москве
rus_verbs:возмечтать{}, // возмечтать о счастливом мире
rus_verbs:вопить{}, // Кто-то вопил о несправедливости
rus_verbs:сказать{}, // сказать что-то новое о ком-то
rus_verbs:знать{}, // знать о ком-то что-то пикантное
rus_verbs:подумать{}, // подумать о чём-то
rus_verbs:думать{}, // думать о чём-то
rus_verbs:узнать{}, // узнать о происшествии
rus_verbs:помнить{}, // помнить о задании
rus_verbs:просить{}, // просить о коде доступа
rus_verbs:забыть{}, // забыть о своих обязанностях
rus_verbs:сообщить{}, // сообщить о заложенной мине
rus_verbs:заявить{}, // заявить о пропаже
rus_verbs:задуматься{}, // задуматься о смерти
rus_verbs:спрашивать{}, // спрашивать о поступлении товара
rus_verbs:догадаться{}, // догадаться о причинах
rus_verbs:договориться{}, // договориться о собеседовании
rus_verbs:мечтать{}, // мечтать о сцене
rus_verbs:поговорить{}, // поговорить о наболевшем
rus_verbs:размышлять{}, // размышлять о насущном
rus_verbs:напоминать{}, // напоминать о себе
rus_verbs:пожалеть{}, // пожалеть о содеянном
rus_verbs:ныть{}, // ныть о прибавке
rus_verbs:сообщать{}, // сообщать о победе
rus_verbs:догадываться{}, // догадываться о первопричине
rus_verbs:поведать{}, // поведать о тайнах
rus_verbs:умолять{}, // умолять о пощаде
rus_verbs:сожалеть{}, // сожалеть о случившемся
rus_verbs:жалеть{}, // жалеть о случившемся
rus_verbs:забывать{}, // забывать о случившемся
rus_verbs:упоминать{}, // упоминать о предках
rus_verbs:позабыть{}, // позабыть о своем обещании
rus_verbs:запеть{}, // запеть о любви
rus_verbs:скорбеть{}, // скорбеть о усопшем
rus_verbs:задумываться{}, // задумываться о смене работы
rus_verbs:позаботиться{}, // позаботиться о престарелых родителях
rus_verbs:докладывать{}, // докладывать о планах строительства целлюлозно-бумажного комбината
rus_verbs:попросить{}, // попросить о замене
rus_verbs:предупредить{}, // предупредить о замене
rus_verbs:предупреждать{}, // предупреждать о замене
rus_verbs:твердить{}, // твердить о замене
rus_verbs:заявлять{}, // заявлять о подлоге
rus_verbs:петь{}, // певица, поющая о лете
rus_verbs:проинформировать{}, // проинформировать о переговорах
rus_verbs:порассказывать{}, // порассказывать о событиях
rus_verbs:послушать{}, // послушать о новинках
rus_verbs:заговорить{}, // заговорить о плате
rus_verbs:отозваться{}, // Он отозвался о книге с большой похвалой.
rus_verbs:оставить{}, // Он оставил о себе печальную память.
rus_verbs:свидетельствовать{}, // страшно исхудавшее тело свидетельствовало о долгих лишениях
rus_verbs:спорить{}, // они спорили о законе
глагол:написать{ aux stress="напис^ать" }, инфинитив:написать{ aux stress="напис^ать" }, // Он написал о том, что видел во время путешествия.
глагол:писать{ aux stress="пис^ать" }, инфинитив:писать{ aux stress="пис^ать" }, // Он писал о том, что видел во время путешествия.
rus_verbs:прочитать{}, // Я прочитал о тебе
rus_verbs:услышать{}, // Я услышал о нем
rus_verbs:помечтать{}, // Девочки помечтали о принце
rus_verbs:слышать{}, // Мальчик слышал о приведениях
rus_verbs:вспомнить{}, // Девочки вспомнили о завтраке
rus_verbs:грустить{}, // Я грущу о тебе
rus_verbs:осведомить{}, // о последних достижениях науки
rus_verbs:рассказывать{}, // Антонио рассказывает о работе
rus_verbs:говорить{}, // говорим о трех больших псах
rus_verbs:идти{} // Вопрос идёт о войне.
}
fact гл_предл
{
if context { Гл_О_предл предлог:о{} *:*{ падеж:предл } }
then return true
}
// Мы поделились впечатлениями о выставке.
// ^^^^^^^^^^ ^^^^^^^^^^
fact гл_предл
{
if context { * предлог:о{} *:*{ падеж:предл } }
then return false,-3
}
fact гл_предл
{
if context { * предлог:о{} *:*{} }
then return false,-5
}
#endregion Предлог_О
#region Предлог_ПО
// ------------------- С ПРЕДЛОГОМ 'ПО' ----------------------
// для этих глаголов - запрещаем связывание с ПО+дат.п.
wordentry_set Глаг_ПО_Дат_Запр=
{
rus_verbs:предпринять{}, // предпринять шаги по стимулированию продаж
rus_verbs:увлечь{}, // увлечь в прогулку по парку
rus_verbs:закончить{},
rus_verbs:мочь{},
rus_verbs:хотеть{}
}
fact гл_предл
{
if context { Глаг_ПО_Дат_Запр предлог:по{} *:*{ падеж:дат } }
then return false,-10
}
// По умолчанию разрешаем связывание в паттернах типа
// Я иду по шоссе
fact гл_предл
{
if context { * предлог:по{} *:*{ падеж:дат } }
then return true
}
wordentry_set Глаг_ПО_Вин=
{
rus_verbs:ВОЙТИ{}, // лезвие вошло по рукоять (ВОЙТИ)
rus_verbs:иметь{}, // все месяцы имели по тридцать дней. (ИМЕТЬ ПО)
rus_verbs:материализоваться{}, // материализоваться по другую сторону барьера
rus_verbs:засадить{}, // засадить по рукоятку
rus_verbs:увязнуть{} // увязнуть по колено
}
fact гл_предл
{
if context { Глаг_ПО_Вин предлог:по{} *:*{ падеж:вин } }
then return true
}
// для остальных падежей запрещаем.
fact гл_предл
{
if context { * предлог:по{} *:*{ падеж:вин } }
then return false,-5
}
#endregion Предлог_ПО
#region Предлог_К
// ------------------- С ПРЕДЛОГОМ 'К' ----------------------
wordentry_set Гл_К_Дат={
rus_verbs:заявиться{}, // Сразу же после обеда к нам заявилась Юлия Михайловна.
rus_verbs:приставлять{} , // Приставляет дуло пистолета к виску.
прилагательное:НЕПРИГОДНЫЙ{}, // большинство компьютеров из этой партии оказались непригодными к эксплуатации (НЕПРИГОДНЫЙ)
rus_verbs:СБЕГАТЬСЯ{}, // Они чуяли воду и сбегались к ней отовсюду. (СБЕГАТЬСЯ)
rus_verbs:СБЕЖАТЬСЯ{}, // К бетонной скамье начали сбегаться люди. (СБЕГАТЬСЯ/СБЕЖАТЬСЯ)
rus_verbs:ПРИТИРАТЬСЯ{}, // Менее стойких водителей буквально сметало на другую полосу, и они впритык притирались к другим машинам. (ПРИТИРАТЬСЯ)
rus_verbs:РУХНУТЬ{}, // а потом ты без чувств рухнул к моим ногам (РУХНУТЬ)
rus_verbs:ПЕРЕНЕСТИ{}, // Они перенесли мясо к ручью и поджарили его на костре. (ПЕРЕНЕСТИ)
rus_verbs:ЗАВЕСТИ{}, // как путь мой завел меня к нему? (ЗАВЕСТИ)
rus_verbs:НАГРЯНУТЬ{}, // ФБР нагрянуло с обыском к сестре бостонских террористов (НАГРЯНУТЬ)
rus_verbs:ПРИСЛОНЯТЬСЯ{}, // Рабы ложились на пол, прислонялись к стене и спали. (ПРИСЛОНЯТЬСЯ,ПРИНОРАВЛИВАТЬСЯ,ПРИНОРОВИТЬСЯ)
rus_verbs:ПРИНОРАВЛИВАТЬСЯ{}, //
rus_verbs:ПРИНОРОВИТЬСЯ{}, //
rus_verbs:СПЛАНИРОВАТЬ{}, // Вскоре она остановила свое падение и спланировала к ним. (СПЛАНИРОВАТЬ,СПИКИРОВАТЬ,РУХНУТЬ)
rus_verbs:СПИКИРОВАТЬ{}, //
rus_verbs:ЗАБРАТЬСЯ{}, // Поэтому он забрался ко мне в квартиру с имевшимся у него полумесяцем. (ЗАБРАТЬСЯ К, В, С)
rus_verbs:ПРОТЯГИВАТЬ{}, // Оно протягивало свои длинные руки к молодому человеку, стоявшему на плоской вершине валуна. (ПРОТЯГИВАТЬ/ПРОТЯНУТЬ/ТЯНУТЬ)
rus_verbs:ПРОТЯНУТЬ{}, //
rus_verbs:ТЯНУТЬ{}, //
rus_verbs:ПЕРЕБИРАТЬСЯ{}, // Ее губы медленно перебирались к его уху. (ПЕРЕБИРАТЬСЯ,ПЕРЕБРАТЬСЯ,ПЕРЕБАЗИРОВАТЬСЯ,ПЕРЕМЕСТИТЬСЯ,ПЕРЕМЕЩАТЬСЯ)
rus_verbs:ПЕРЕБРАТЬСЯ{}, // ,,,
rus_verbs:ПЕРЕБАЗИРОВАТЬСЯ{}, //
rus_verbs:ПЕРЕМЕСТИТЬСЯ{}, //
rus_verbs:ПЕРЕМЕЩАТЬСЯ{}, //
rus_verbs:ТРОНУТЬСЯ{}, // Он отвернулся от нее и тронулся к пляжу. (ТРОНУТЬСЯ)
rus_verbs:ПРИСТАВИТЬ{}, // Он поднял одну из них и приставил верхний конец к краю шахты в потолке.
rus_verbs:ПРОБИТЬСЯ{}, // Отряд с невероятными приключениями, пытается пробиться к своему полку, попадает в плен и другие передряги (ПРОБИТЬСЯ)
rus_verbs:хотеть{},
rus_verbs:СДЕЛАТЬ{}, // Сделайте всё к понедельнику (СДЕЛАТЬ)
rus_verbs:ИСПЫТЫВАТЬ{}, // она испытывает ко мне только отвращение (ИСПЫТЫВАТЬ)
rus_verbs:ОБЯЗЫВАТЬ{}, // Это меня ни к чему не обязывает (ОБЯЗЫВАТЬ)
rus_verbs:КАРАБКАТЬСЯ{}, // карабкаться по горе от подножия к вершине (КАРАБКАТЬСЯ)
rus_verbs:СТОЯТЬ{}, // мужчина стоял ко мне спиной (СТОЯТЬ)
rus_verbs:ПОДАТЬСЯ{}, // наконец люк подался ко мне (ПОДАТЬСЯ)
rus_verbs:ПРИРАВНЯТЬ{}, // Усилия нельзя приравнять к результату (ПРИРАВНЯТЬ)
rus_verbs:ПРИРАВНИВАТЬ{}, // Усилия нельзя приравнивать к результату (ПРИРАВНИВАТЬ)
rus_verbs:ВОЗЛОЖИТЬ{}, // Путин в Пскове возложил цветы к памятнику воинам-десантникам, погибшим в Чечне (ВОЗЛОЖИТЬ)
rus_verbs:запустить{}, // Индия запустит к Марсу свой космический аппарат в 2013 г
rus_verbs:ПРИСТЫКОВАТЬСЯ{}, // Роботизированный российский грузовой космический корабль пристыковался к МКС (ПРИСТЫКОВАТЬСЯ)
rus_verbs:ПРИМАЗАТЬСЯ{}, // К челябинскому метеориту примазалась таинственная слизь (ПРИМАЗАТЬСЯ)
rus_verbs:ПОПРОСИТЬ{}, // Попросите Лизу к телефону (ПОПРОСИТЬ К)
rus_verbs:ПРОЕХАТЬ{}, // Порой школьные автобусы просто не имеют возможности проехать к некоторым населенным пунктам из-за бездорожья (ПРОЕХАТЬ К)
rus_verbs:ПОДЦЕПЛЯТЬСЯ{}, // Вагоны с пассажирами подцепляются к составу (ПОДЦЕПЛЯТЬСЯ К)
rus_verbs:ПРИЗВАТЬ{}, // Президент Афганистана призвал талибов к прямому диалогу (ПРИЗВАТЬ К)
rus_verbs:ПРЕОБРАЗИТЬСЯ{}, // Культовый столичный отель преобразился к юбилею (ПРЕОБРАЗИТЬСЯ К)
прилагательное:ЧУВСТВИТЕЛЬНЫЙ{}, // нейроны одного комплекса чувствительны к разным веществам (ЧУВСТВИТЕЛЬНЫЙ К)
безлич_глагол:нужно{}, // нам нужно к воротам (НУЖНО К)
rus_verbs:БРОСИТЬ{}, // огромный клюв бросил это мясо к моим ногам (БРОСИТЬ К)
rus_verbs:ЗАКОНЧИТЬ{}, // к пяти утра техники закончили (ЗАКОНЧИТЬ К)
rus_verbs:НЕСТИ{}, // к берегу нас несет! (НЕСТИ К)
rus_verbs:ПРОДВИГАТЬСЯ{}, // племена медленно продвигались к востоку (ПРОДВИГАТЬСЯ К)
rus_verbs:ОПУСКАТЬСЯ{}, // деревья опускались к самой воде (ОПУСКАТЬСЯ К)
rus_verbs:СТЕМНЕТЬ{}, // к тому времени стемнело (СТЕМНЕЛО К)
rus_verbs:ОТСКОЧИТЬ{}, // после отскочил к окну (ОТСКОЧИТЬ К)
rus_verbs:ДЕРЖАТЬСЯ{}, // к солнцу держались спинами (ДЕРЖАТЬСЯ К)
rus_verbs:КАЧНУТЬСЯ{}, // толпа качнулась к ступеням (КАЧНУТЬСЯ К)
rus_verbs:ВОЙТИ{}, // Андрей вошел к себе (ВОЙТИ К)
rus_verbs:ВЫБРАТЬСЯ{}, // мы выбрались к окну (ВЫБРАТЬСЯ К)
rus_verbs:ПРОВЕСТИ{}, // провел к стене спальни (ПРОВЕСТИ К)
rus_verbs:ВЕРНУТЬСЯ{}, // давай вернемся к делу (ВЕРНУТЬСЯ К)
rus_verbs:ВОЗВРАТИТЬСЯ{}, // Среди евреев, живших в диаспоре, всегда было распространено сильное стремление возвратиться к Сиону (ВОЗВРАТИТЬСЯ К)
rus_verbs:ПРИЛЕГАТЬ{}, // Задняя поверхность хрусталика прилегает к стекловидному телу (ПРИЛЕГАТЬ К)
rus_verbs:ПЕРЕНЕСТИСЬ{}, // мысленно Алёна перенеслась к заливу (ПЕРЕНЕСТИСЬ К)
rus_verbs:ПРОБИВАТЬСЯ{}, // сквозь болото к берегу пробивался ручей. (ПРОБИВАТЬСЯ К)
rus_verbs:ПЕРЕВЕСТИ{}, // необходимо срочно перевести стадо к воде. (ПЕРЕВЕСТИ К)
rus_verbs:ПРИЛЕТЕТЬ{}, // зачем ты прилетел к нам? (ПРИЛЕТЕТЬ К)
rus_verbs:ДОБАВИТЬ{}, // добавить ли ее к остальным? (ДОБАВИТЬ К)
rus_verbs:ПРИГОТОВИТЬ{}, // Матвей приготовил лук к бою. (ПРИГОТОВИТЬ К)
rus_verbs:РВАНУТЬ{}, // человек рванул ее к себе. (РВАНУТЬ К)
rus_verbs:ТАЩИТЬ{}, // они тащили меня к двери. (ТАЩИТЬ К)
глагол:быть{}, // к тебе есть вопросы.
прилагательное:равнодушный{}, // Он равнодушен к музыке.
rus_verbs:ПОЖАЛОВАТЬ{}, // скандально известный певец пожаловал к нам на передачу (ПОЖАЛОВАТЬ К)
rus_verbs:ПЕРЕСЕСТЬ{}, // Ольга пересела к Антону (ПЕРЕСЕСТЬ К)
инфинитив:СБЕГАТЬ{ вид:соверш }, глагол:СБЕГАТЬ{ вид:соверш }, // сбегай к Борису (СБЕГАТЬ К)
rus_verbs:ПЕРЕХОДИТЬ{}, // право хода переходит к Адаму (ПЕРЕХОДИТЬ К)
rus_verbs:прижаться{}, // она прижалась щекой к его шее. (прижаться+к)
rus_verbs:ПОДСКОЧИТЬ{}, // солдат быстро подскочил ко мне. (ПОДСКОЧИТЬ К)
rus_verbs:ПРОБРАТЬСЯ{}, // нужно пробраться к реке. (ПРОБРАТЬСЯ К)
rus_verbs:ГОТОВИТЬ{}, // нас готовили к этому. (ГОТОВИТЬ К)
rus_verbs:ТЕЧЬ{}, // река текла к морю. (ТЕЧЬ К)
rus_verbs:ОТШАТНУТЬСЯ{}, // епископ отшатнулся к стене. (ОТШАТНУТЬСЯ К)
rus_verbs:БРАТЬ{}, // брали бы к себе. (БРАТЬ К)
rus_verbs:СКОЛЬЗНУТЬ{}, // ковер скользнул к пещере. (СКОЛЬЗНУТЬ К)
rus_verbs:присохнуть{}, // Грязь присохла к одежде. (присохнуть к)
rus_verbs:просить{}, // Директор просит вас к себе. (просить к)
rus_verbs:вызывать{}, // шеф вызывал к себе. (вызывать к)
rus_verbs:присесть{}, // старик присел к огню. (присесть к)
rus_verbs:НАКЛОНИТЬСЯ{}, // Ричард наклонился к брату. (НАКЛОНИТЬСЯ К)
rus_verbs:выбираться{}, // будем выбираться к дороге. (выбираться к)
rus_verbs:отвернуться{}, // Виктор отвернулся к стене. (отвернуться к)
rus_verbs:СТИХНУТЬ{}, // огонь стих к полудню. (СТИХНУТЬ К)
rus_verbs:УПАСТЬ{}, // нож упал к ногам. (УПАСТЬ К)
rus_verbs:СЕСТЬ{}, // молча сел к огню. (СЕСТЬ К)
rus_verbs:ХЛЫНУТЬ{}, // народ хлынул к стенам. (ХЛЫНУТЬ К)
rus_verbs:покатиться{}, // они черной волной покатились ко мне. (покатиться к)
rus_verbs:ОБРАТИТЬ{}, // она обратила к нему свое бледное лицо. (ОБРАТИТЬ К)
rus_verbs:СКЛОНИТЬ{}, // Джон слегка склонил голову к плечу. (СКЛОНИТЬ К)
rus_verbs:СВЕРНУТЬ{}, // дорожка резко свернула к южной стене. (СВЕРНУТЬ К)
rus_verbs:ЗАВЕРНУТЬ{}, // Он завернул к нам по пути к месту службы. (ЗАВЕРНУТЬ К)
rus_verbs:подходить{}, // цвет подходил ей к лицу.
rus_verbs:БРЕСТИ{}, // Ричард покорно брел к отцу. (БРЕСТИ К)
rus_verbs:ПОПАСТЬ{}, // хочешь попасть к нему? (ПОПАСТЬ К)
rus_verbs:ПОДНЯТЬ{}, // Мартин поднял ружье к плечу. (ПОДНЯТЬ К)
rus_verbs:ПОТЕРЯТЬ{}, // просто потеряла к нему интерес. (ПОТЕРЯТЬ К)
rus_verbs:РАЗВЕРНУТЬСЯ{}, // они сразу развернулись ко мне. (РАЗВЕРНУТЬСЯ К)
rus_verbs:ПОВЕРНУТЬ{}, // мальчик повернул к ним голову. (ПОВЕРНУТЬ К)
rus_verbs:вызвать{}, // или вызвать к жизни? (вызвать к)
rus_verbs:ВЫХОДИТЬ{}, // их земли выходят к морю. (ВЫХОДИТЬ К)
rus_verbs:ЕХАТЬ{}, // мы долго ехали к вам. (ЕХАТЬ К)
rus_verbs:опуститься{}, // Алиса опустилась к самому дну. (опуститься к)
rus_verbs:подняться{}, // они молча поднялись к себе. (подняться к)
rus_verbs:ДВИНУТЬСЯ{}, // толстяк тяжело двинулся к ним. (ДВИНУТЬСЯ К)
rus_verbs:ПОПЯТИТЬСЯ{}, // ведьмак осторожно попятился к лошади. (ПОПЯТИТЬСЯ К)
rus_verbs:РИНУТЬСЯ{}, // мышелов ринулся к черной стене. (РИНУТЬСЯ К)
rus_verbs:ТОЛКНУТЬ{}, // к этому толкнул ее ты. (ТОЛКНУТЬ К)
rus_verbs:отпрыгнуть{}, // Вадим поспешно отпрыгнул к борту. (отпрыгнуть к)
rus_verbs:отступить{}, // мы поспешно отступили к стене. (отступить к)
rus_verbs:ЗАБРАТЬ{}, // мы забрали их к себе. (ЗАБРАТЬ к)
rus_verbs:ВЗЯТЬ{}, // потом возьму тебя к себе. (ВЗЯТЬ К)
rus_verbs:лежать{}, // наш путь лежал к ним. (лежать к)
rus_verbs:поползти{}, // ее рука поползла к оружию. (поползти к)
rus_verbs:требовать{}, // вас требует к себе император. (требовать к)
rus_verbs:поехать{}, // ты должен поехать к нему. (поехать к)
rus_verbs:тянуться{}, // мордой животное тянулось к земле. (тянуться к)
rus_verbs:ЖДАТЬ{}, // жди их завтра к утру. (ЖДАТЬ К)
rus_verbs:ПОЛЕТЕТЬ{}, // они стремительно полетели к земле. (ПОЛЕТЕТЬ К)
rus_verbs:подойти{}, // помоги мне подойти к столу. (подойти к)
rus_verbs:РАЗВЕРНУТЬ{}, // мужик развернул к нему коня. (РАЗВЕРНУТЬ К)
rus_verbs:ПРИВЕЗТИ{}, // нас привезли прямо к королю. (ПРИВЕЗТИ К)
rus_verbs:отпрянуть{}, // незнакомец отпрянул к стене. (отпрянуть к)
rus_verbs:побежать{}, // Cергей побежал к двери. (побежать к)
rus_verbs:отбросить{}, // сильный удар отбросил его к стене. (отбросить к)
rus_verbs:ВЫНУДИТЬ{}, // они вынудили меня к сотрудничеству (ВЫНУДИТЬ К)
rus_verbs:подтянуть{}, // он подтянул к себе стул и сел на него (подтянуть к)
rus_verbs:сойти{}, // по узкой тропинке путники сошли к реке. (сойти к)
rus_verbs:являться{}, // по ночам к нему являлись призраки. (являться к)
rus_verbs:ГНАТЬ{}, // ледяной ветер гнал их к югу. (ГНАТЬ К)
rus_verbs:ВЫВЕСТИ{}, // она вывела нас точно к месту. (ВЫВЕСТИ К)
rus_verbs:выехать{}, // почти сразу мы выехали к реке.
rus_verbs:пододвигаться{}, // пододвигайся к окну
rus_verbs:броситься{}, // большая часть защитников стен бросилась к воротам.
rus_verbs:представить{}, // Его представили к ордену.
rus_verbs:двигаться{}, // между тем чудище неторопливо двигалось к берегу.
rus_verbs:выскочить{}, // тем временем они выскочили к реке.
rus_verbs:выйти{}, // тем временем они вышли к лестнице.
rus_verbs:потянуть{}, // Мальчик схватил верёвку и потянул её к себе.
rus_verbs:приложить{}, // приложить к детали повышенное усилие
rus_verbs:пройти{}, // пройти к стойке регистрации (стойка регистрации - проверить проверку)
rus_verbs:отнестись{}, // отнестись к животным с сочуствием
rus_verbs:привязать{}, // привязать за лапу веревкой к колышку, воткнутому в землю
rus_verbs:прыгать{}, // прыгать к хозяину на стол
rus_verbs:приглашать{}, // приглашать к доктору
rus_verbs:рваться{}, // Чужие люди рвутся к власти
rus_verbs:понестись{}, // понестись к обрыву
rus_verbs:питать{}, // питать привязанность к алкоголю
rus_verbs:заехать{}, // Коля заехал к Оле
rus_verbs:переехать{}, // переехать к родителям
rus_verbs:ползти{}, // ползти к дороге
rus_verbs:сводиться{}, // сводиться к элементарному действию
rus_verbs:добавлять{}, // добавлять к общей сумме
rus_verbs:подбросить{}, // подбросить к потолку
rus_verbs:призывать{}, // призывать к спокойствию
rus_verbs:пробираться{}, // пробираться к партизанам
rus_verbs:отвезти{}, // отвезти к родителям
rus_verbs:применяться{}, // применяться к уравнению
rus_verbs:сходиться{}, // сходиться к точному решению
rus_verbs:допускать{}, // допускать к сдаче зачета
rus_verbs:свести{}, // свести к нулю
rus_verbs:придвинуть{}, // придвинуть к мальчику
rus_verbs:подготовить{}, // подготовить к печати
rus_verbs:подобраться{}, // подобраться к оленю
rus_verbs:заторопиться{}, // заторопиться к выходу
rus_verbs:пристать{}, // пристать к берегу
rus_verbs:поманить{}, // поманить к себе
rus_verbs:припасть{}, // припасть к алтарю
rus_verbs:притащить{}, // притащить к себе домой
rus_verbs:прижимать{}, // прижимать к груди
rus_verbs:подсесть{}, // подсесть к симпатичной девочке
rus_verbs:придвинуться{}, // придвинуться к окну
rus_verbs:отпускать{}, // отпускать к другу
rus_verbs:пригнуться{}, // пригнуться к земле
rus_verbs:пристроиться{}, // пристроиться к колонне
rus_verbs:сгрести{}, // сгрести к себе
rus_verbs:удрать{}, // удрать к цыганам
rus_verbs:прибавиться{}, // прибавиться к общей сумме
rus_verbs:присмотреться{}, // присмотреться к покупке
rus_verbs:подкатить{}, // подкатить к трюму
rus_verbs:клонить{}, // клонить ко сну
rus_verbs:проследовать{}, // проследовать к выходу
rus_verbs:пододвинуть{}, // пододвинуть к себе
rus_verbs:применять{}, // применять к сотрудникам
rus_verbs:прильнуть{}, // прильнуть к экранам
rus_verbs:подвинуть{}, // подвинуть к себе
rus_verbs:примчаться{}, // примчаться к папе
rus_verbs:подкрасться{}, // подкрасться к жертве
rus_verbs:привязаться{}, // привязаться к собаке
rus_verbs:забирать{}, // забирать к себе
rus_verbs:прорваться{}, // прорваться к кассе
rus_verbs:прикасаться{}, // прикасаться к коже
rus_verbs:уносить{}, // уносить к себе
rus_verbs:подтянуться{}, // подтянуться к месту
rus_verbs:привозить{}, // привозить к ветеринару
rus_verbs:подползти{}, // подползти к зайцу
rus_verbs:приблизить{}, // приблизить к глазам
rus_verbs:применить{}, // применить к уравнению простое преобразование
rus_verbs:приглядеться{}, // приглядеться к изображению
rus_verbs:приложиться{}, // приложиться к ручке
rus_verbs:приставать{}, // приставать к девчонкам
rus_verbs:запрещаться{}, // запрещаться к показу
rus_verbs:прибегать{}, // прибегать к насилию
rus_verbs:побудить{}, // побудить к действиям
rus_verbs:притягивать{}, // притягивать к себе
rus_verbs:пристроить{}, // пристроить к полезному делу
rus_verbs:приговорить{}, // приговорить к смерти
rus_verbs:склоняться{}, // склоняться к прекращению разработки
rus_verbs:подъезжать{}, // подъезжать к вокзалу
rus_verbs:привалиться{}, // привалиться к забору
rus_verbs:наклоняться{}, // наклоняться к щенку
rus_verbs:подоспеть{}, // подоспеть к обеду
rus_verbs:прилипнуть{}, // прилипнуть к окну
rus_verbs:приволочь{}, // приволочь к себе
rus_verbs:устремляться{}, // устремляться к вершине
rus_verbs:откатиться{}, // откатиться к исходным позициям
rus_verbs:побуждать{}, // побуждать к действиям
rus_verbs:прискакать{}, // прискакать к кормежке
rus_verbs:присматриваться{}, // присматриваться к новичку
rus_verbs:прижиматься{}, // прижиматься к борту
rus_verbs:жаться{}, // жаться к огню
rus_verbs:передвинуть{}, // передвинуть к окну
rus_verbs:допускаться{}, // допускаться к экзаменам
rus_verbs:прикрепить{}, // прикрепить к корпусу
rus_verbs:отправлять{}, // отправлять к специалистам
rus_verbs:перебежать{}, // перебежать к врагам
rus_verbs:притронуться{}, // притронуться к реликвии
rus_verbs:заспешить{}, // заспешить к семье
rus_verbs:ревновать{}, // ревновать к сопернице
rus_verbs:подступить{}, // подступить к горлу
rus_verbs:уводить{}, // уводить к ветеринару
rus_verbs:побросать{}, // побросать к ногам
rus_verbs:подаваться{}, // подаваться к ужину
rus_verbs:приписывать{}, // приписывать к достижениям
rus_verbs:относить{}, // относить к растениям
rus_verbs:принюхаться{}, // принюхаться к ароматам
rus_verbs:подтащить{}, // подтащить к себе
rus_verbs:прислонить{}, // прислонить к стене
rus_verbs:подплыть{}, // подплыть к бую
rus_verbs:опаздывать{}, // опаздывать к стилисту
rus_verbs:примкнуть{}, // примкнуть к деомнстрантам
rus_verbs:стекаться{}, // стекаются к стенам тюрьмы
rus_verbs:подготовиться{}, // подготовиться к марафону
rus_verbs:приглядываться{}, // приглядываться к новичку
rus_verbs:присоединяться{}, // присоединяться к сообществу
rus_verbs:клониться{}, // клониться ко сну
rus_verbs:привыкать{}, // привыкать к хорошему
rus_verbs:принудить{}, // принудить к миру
rus_verbs:уплыть{}, // уплыть к далекому берегу
rus_verbs:утащить{}, // утащить к детенышам
rus_verbs:приплыть{}, // приплыть к финишу
rus_verbs:подбегать{}, // подбегать к хозяину
rus_verbs:лишаться{}, // лишаться средств к существованию
rus_verbs:приступать{}, // приступать к операции
rus_verbs:пробуждать{}, // пробуждать лекцией интерес к математике
rus_verbs:подключить{}, // подключить к трубе
rus_verbs:подключиться{}, // подключиться к сети
rus_verbs:прилить{}, // прилить к лицу
rus_verbs:стучаться{}, // стучаться к соседям
rus_verbs:пристегнуть{}, // пристегнуть к креслу
rus_verbs:присоединить{}, // присоединить к сети
rus_verbs:отбежать{}, // отбежать к противоположной стене
rus_verbs:подвезти{}, // подвезти к набережной
rus_verbs:прибегнуть{}, // прибегнуть к хитрости
rus_verbs:приучить{}, // приучить к туалету
rus_verbs:подталкивать{}, // подталкивать к выходу
rus_verbs:прорываться{}, // прорываться к выходу
rus_verbs:увозить{}, // увозить к ветеринару
rus_verbs:засеменить{}, // засеменить к выходу
rus_verbs:крепиться{}, // крепиться к потолку
rus_verbs:прибрать{}, // прибрать к рукам
rus_verbs:пристраститься{}, // пристраститься к наркотикам
rus_verbs:поспеть{}, // поспеть к обеду
rus_verbs:привязывать{}, // привязывать к дереву
rus_verbs:прилагать{}, // прилагать к документам
rus_verbs:переправить{}, // переправить к дедушке
rus_verbs:подогнать{}, // подогнать к воротам
rus_verbs:тяготеть{}, // тяготеть к социализму
rus_verbs:подбираться{}, // подбираться к оленю
rus_verbs:подступать{}, // подступать к горлу
rus_verbs:примыкать{}, // примыкать к первому элементу
rus_verbs:приладить{}, // приладить к велосипеду
rus_verbs:подбрасывать{}, // подбрасывать к потолку
rus_verbs:перевозить{}, // перевозить к новому месту дислокации
rus_verbs:усаживаться{}, // усаживаться к окну
rus_verbs:приближать{}, // приближать к глазам
rus_verbs:попроситься{}, // попроситься к бабушке
rus_verbs:прибить{}, // прибить к доске
rus_verbs:перетащить{}, // перетащить к себе
rus_verbs:прицепить{}, // прицепить к паровозу
rus_verbs:прикладывать{}, // прикладывать к ране
rus_verbs:устареть{}, // устареть к началу войны
rus_verbs:причалить{}, // причалить к пристани
rus_verbs:приспособиться{}, // приспособиться к опозданиям
rus_verbs:принуждать{}, // принуждать к миру
rus_verbs:соваться{}, // соваться к директору
rus_verbs:протолкаться{}, // протолкаться к прилавку
rus_verbs:приковать{}, // приковать к батарее
rus_verbs:подкрадываться{}, // подкрадываться к суслику
rus_verbs:подсадить{}, // подсадить к арестонту
rus_verbs:прикатить{}, // прикатить к финишу
rus_verbs:протащить{}, // протащить к владыке
rus_verbs:сужаться{}, // сужаться к основанию
rus_verbs:присовокупить{}, // присовокупить к пожеланиям
rus_verbs:пригвоздить{}, // пригвоздить к доске
rus_verbs:отсылать{}, // отсылать к первоисточнику
rus_verbs:изготовиться{}, // изготовиться к прыжку
rus_verbs:прилагаться{}, // прилагаться к покупке
rus_verbs:прицепиться{}, // прицепиться к вагону
rus_verbs:примешиваться{}, // примешиваться к вину
rus_verbs:переселить{}, // переселить к старшекурсникам
rus_verbs:затрусить{}, // затрусить к выходе
rus_verbs:приспособить{}, // приспособить к обогреву
rus_verbs:примериться{}, // примериться к аппарату
rus_verbs:прибавляться{}, // прибавляться к пенсии
rus_verbs:подкатиться{}, // подкатиться к воротам
rus_verbs:стягивать{}, // стягивать к границе
rus_verbs:дописать{}, // дописать к роману
rus_verbs:подпустить{}, // подпустить к корове
rus_verbs:склонять{}, // склонять к сотрудничеству
rus_verbs:припечатать{}, // припечатать к стене
rus_verbs:охладеть{}, // охладеть к музыке
rus_verbs:пришить{}, // пришить к шинели
rus_verbs:принюхиваться{}, // принюхиваться к ветру
rus_verbs:подрулить{}, // подрулить к барышне
rus_verbs:наведаться{}, // наведаться к оракулу
rus_verbs:клеиться{}, // клеиться к конверту
rus_verbs:перетянуть{}, // перетянуть к себе
rus_verbs:переметнуться{}, // переметнуться к конкурентам
rus_verbs:липнуть{}, // липнуть к сокурсницам
rus_verbs:поковырять{}, // поковырять к выходу
rus_verbs:подпускать{}, // подпускать к пульту управления
rus_verbs:присосаться{}, // присосаться к источнику
rus_verbs:приклеить{}, // приклеить к стеклу
rus_verbs:подтягивать{}, // подтягивать к себе
rus_verbs:подкатывать{}, // подкатывать к даме
rus_verbs:притрагиваться{}, // притрагиваться к опухоли
rus_verbs:слетаться{}, // слетаться к водопою
rus_verbs:хаживать{}, // хаживать к батюшке
rus_verbs:привлекаться{}, // привлекаться к административной ответственности
rus_verbs:подзывать{}, // подзывать к себе
rus_verbs:прикладываться{}, // прикладываться к иконе
rus_verbs:подтягиваться{}, // подтягиваться к парламенту
rus_verbs:прилепить{}, // прилепить к стенке холодильника
rus_verbs:пододвинуться{}, // пододвинуться к экрану
rus_verbs:приползти{}, // приползти к дереву
rus_verbs:запаздывать{}, // запаздывать к обеду
rus_verbs:припереть{}, // припереть к стене
rus_verbs:нагибаться{}, // нагибаться к цветку
инфинитив:сгонять{ вид:соверш }, глагол:сгонять{ вид:соверш }, // сгонять к воротам
деепричастие:сгоняв{},
rus_verbs:поковылять{}, // поковылять к выходу
rus_verbs:привалить{}, // привалить к столбу
rus_verbs:отпроситься{}, // отпроситься к родителям
rus_verbs:приспосабливаться{}, // приспосабливаться к новым условиям
rus_verbs:прилипать{}, // прилипать к рукам
rus_verbs:подсоединить{}, // подсоединить к приборам
rus_verbs:приливать{}, // приливать к голове
rus_verbs:подселить{}, // подселить к другим новичкам
rus_verbs:прилепиться{}, // прилепиться к шкуре
rus_verbs:подлетать{}, // подлетать к пункту назначения
rus_verbs:пристегнуться{}, // пристегнуться к креслу ремнями
rus_verbs:прибиться{}, // прибиться к стае, улетающей на юг
rus_verbs:льнуть{}, // льнуть к заботливому хозяину
rus_verbs:привязываться{}, // привязываться к любящему хозяину
rus_verbs:приклеиться{}, // приклеиться к спине
rus_verbs:стягиваться{}, // стягиваться к сенату
rus_verbs:подготавливать{}, // подготавливать к выходу на арену
rus_verbs:приглашаться{}, // приглашаться к доктору
rus_verbs:причислять{}, // причислять к отличникам
rus_verbs:приколоть{}, // приколоть к лацкану
rus_verbs:наклонять{}, // наклонять к горизонту
rus_verbs:припадать{}, // припадать к первоисточнику
rus_verbs:приобщиться{}, // приобщиться к культурному наследию
rus_verbs:придираться{}, // придираться к мелким ошибкам
rus_verbs:приучать{}, // приучать к лотку
rus_verbs:промотать{}, // промотать к началу
rus_verbs:прихлынуть{}, // прихлынуть к голове
rus_verbs:пришвартоваться{}, // пришвартоваться к первому пирсу
rus_verbs:прикрутить{}, // прикрутить к велосипеду
rus_verbs:подплывать{}, // подплывать к лодке
rus_verbs:приравниваться{}, // приравниваться к побегу
rus_verbs:подстрекать{}, // подстрекать к вооруженной борьбе с оккупантами
rus_verbs:изготовляться{}, // изготовляться к прыжку из стратосферы
rus_verbs:приткнуться{}, // приткнуться к первой группе туристов
rus_verbs:приручить{}, // приручить котика к лотку
rus_verbs:приковывать{}, // приковывать к себе все внимание прессы
rus_verbs:приготовляться{}, // приготовляться к первому экзамену
rus_verbs:остыть{}, // Вода остынет к утру.
rus_verbs:приехать{}, // Он приедет к концу будущей недели.
rus_verbs:подсаживаться{},
rus_verbs:успевать{}, // успевать к стилисту
rus_verbs:привлекать{}, // привлекать к себе внимание
прилагательное:устойчивый{}, // переводить в устойчивую к перегреву форму
rus_verbs:прийтись{}, // прийтись ко двору
инфинитив:адаптировать{вид:несоверш}, // машина была адаптирована к условиям крайнего севера
инфинитив:адаптировать{вид:соверш},
глагол:адаптировать{вид:несоверш},
глагол:адаптировать{вид:соверш},
деепричастие:адаптировав{},
деепричастие:адаптируя{},
прилагательное:адаптирующий{},
прилагательное:адаптировавший{ вид:соверш },
//+прилагательное:адаптировавший{ вид:несоверш },
прилагательное:адаптированный{},
инфинитив:адаптироваться{вид:соверш}, // тело адаптировалось к условиям суровой зимы
инфинитив:адаптироваться{вид:несоверш},
глагол:адаптироваться{вид:соверш},
глагол:адаптироваться{вид:несоверш},
деепричастие:адаптировавшись{},
деепричастие:адаптируясь{},
прилагательное:адаптировавшийся{вид:соверш},
//+прилагательное:адаптировавшийся{вид:несоверш},
прилагательное:адаптирующийся{},
rus_verbs:апеллировать{}, // оратор апеллировал к патриотизму своих слушателей
rus_verbs:близиться{}, // Шторм близится к побережью
rus_verbs:доставить{}, // Эскиз ракеты, способной доставить корабль к Луне
rus_verbs:буксировать{}, // Буксир буксирует танкер к месту стоянки
rus_verbs:причислить{}, // Мы причислили его к числу экспертов
rus_verbs:вести{}, // Наша партия ведет народ к процветанию
rus_verbs:взывать{}, // Учителя взывают к совести хулигана
rus_verbs:воззвать{}, // воззвать соплеменников к оружию
rus_verbs:возревновать{}, // возревновать к поклонникам
rus_verbs:воспылать{}, // Коля воспылал к Оле страстной любовью
rus_verbs:восходить{}, // восходить к вершине
rus_verbs:восшествовать{}, // восшествовать к вершине
rus_verbs:успеть{}, // успеть к обеду
rus_verbs:повернуться{}, // повернуться к кому-то
rus_verbs:обратиться{}, // обратиться к охраннику
rus_verbs:звать{}, // звать к столу
rus_verbs:отправиться{}, // отправиться к парикмахеру
rus_verbs:обернуться{}, // обернуться к зовущему
rus_verbs:явиться{}, // явиться к следователю
rus_verbs:уехать{}, // уехать к родне
rus_verbs:прибыть{}, // прибыть к перекличке
rus_verbs:привыкнуть{}, // привыкнуть к голоду
rus_verbs:уходить{}, // уходить к цыганам
rus_verbs:привести{}, // привести к себе
rus_verbs:шагнуть{}, // шагнуть к славе
rus_verbs:относиться{}, // относиться к прежним периодам
rus_verbs:подослать{}, // подослать к врагам
rus_verbs:поспешить{}, // поспешить к обеду
rus_verbs:зайти{}, // зайти к подруге
rus_verbs:позвать{}, // позвать к себе
rus_verbs:потянуться{}, // потянуться к рычагам
rus_verbs:пускать{}, // пускать к себе
rus_verbs:отвести{}, // отвести к врачу
rus_verbs:приблизиться{}, // приблизиться к решению задачи
rus_verbs:прижать{}, // прижать к стене
rus_verbs:отправить{}, // отправить к доктору
rus_verbs:падать{}, // падать к многолетним минимумам
rus_verbs:полезть{}, // полезть к дерущимся
rus_verbs:лезть{}, // Ты сама ко мне лезла!
rus_verbs:направить{}, // направить к майору
rus_verbs:приводить{}, // приводить к дантисту
rus_verbs:кинуться{}, // кинуться к двери
rus_verbs:поднести{}, // поднести к глазам
rus_verbs:подниматься{}, // подниматься к себе
rus_verbs:прибавить{}, // прибавить к результату
rus_verbs:зашагать{}, // зашагать к выходу
rus_verbs:склониться{}, // склониться к земле
rus_verbs:стремиться{}, // стремиться к вершине
rus_verbs:лететь{}, // лететь к родственникам
rus_verbs:ездить{}, // ездить к любовнице
rus_verbs:приближаться{}, // приближаться к финише
rus_verbs:помчаться{}, // помчаться к стоматологу
rus_verbs:прислушаться{}, // прислушаться к происходящему
rus_verbs:изменить{}, // изменить к лучшему собственную жизнь
rus_verbs:проявить{}, // проявить к погибшим сострадание
rus_verbs:подбежать{}, // подбежать к упавшему
rus_verbs:терять{}, // терять к партнерам доверие
rus_verbs:пропустить{}, // пропустить к певцу
rus_verbs:подвести{}, // подвести к глазам
rus_verbs:меняться{}, // меняться к лучшему
rus_verbs:заходить{}, // заходить к другу
rus_verbs:рвануться{}, // рвануться к воде
rus_verbs:привлечь{}, // привлечь к себе внимание
rus_verbs:присоединиться{}, // присоединиться к сети
rus_verbs:приезжать{}, // приезжать к дедушке
rus_verbs:дернуться{}, // дернуться к борту
rus_verbs:подъехать{}, // подъехать к воротам
rus_verbs:готовиться{}, // готовиться к дождю
rus_verbs:убежать{}, // убежать к маме
rus_verbs:поднимать{}, // поднимать к источнику сигнала
rus_verbs:отослать{}, // отослать к руководителю
rus_verbs:приготовиться{}, // приготовиться к худшему
rus_verbs:приступить{}, // приступить к выполнению обязанностей
rus_verbs:метнуться{}, // метнуться к фонтану
rus_verbs:прислушиваться{}, // прислушиваться к голосу разума
rus_verbs:побрести{}, // побрести к выходу
rus_verbs:мчаться{}, // мчаться к успеху
rus_verbs:нестись{}, // нестись к обрыву
rus_verbs:попадать{}, // попадать к хорошему костоправу
rus_verbs:опоздать{}, // опоздать к психотерапевту
rus_verbs:посылать{}, // посылать к доктору
rus_verbs:поплыть{}, // поплыть к берегу
rus_verbs:подтолкнуть{}, // подтолкнуть к активной работе
rus_verbs:отнести{}, // отнести животное к ветеринару
rus_verbs:прислониться{}, // прислониться к стволу
rus_verbs:наклонить{}, // наклонить к миске с молоком
rus_verbs:прикоснуться{}, // прикоснуться к поверхности
rus_verbs:увезти{}, // увезти к бабушке
rus_verbs:заканчиваться{}, // заканчиваться к концу путешествия
rus_verbs:подозвать{}, // подозвать к себе
rus_verbs:улететь{}, // улететь к теплым берегам
rus_verbs:ложиться{}, // ложиться к мужу
rus_verbs:убираться{}, // убираться к чертовой бабушке
rus_verbs:класть{}, // класть к другим документам
rus_verbs:доставлять{}, // доставлять к подъезду
rus_verbs:поворачиваться{}, // поворачиваться к источнику шума
rus_verbs:заглядывать{}, // заглядывать к любовнице
rus_verbs:занести{}, // занести к заказчикам
rus_verbs:прибежать{}, // прибежать к папе
rus_verbs:притянуть{}, // притянуть к причалу
rus_verbs:переводить{}, // переводить в устойчивую к перегреву форму
rus_verbs:подать{}, // он подал лимузин к подъезду
rus_verbs:подавать{}, // она подавала соус к мясу
rus_verbs:приобщаться{}, // приобщаться к культуре
прилагательное:неспособный{}, // Наша дочка неспособна к учению.
прилагательное:неприспособленный{}, // Эти устройства неприспособлены к работе в жару
прилагательное:предназначенный{}, // Старый дом предназначен к сносу.
прилагательное:внимательный{}, // Она всегда внимательна к гостям.
прилагательное:назначенный{}, // Дело назначено к докладу.
прилагательное:разрешенный{}, // Эта книга разрешена к печати.
прилагательное:снисходительный{}, // Этот учитель снисходителен к ученикам.
прилагательное:готовый{}, // Я готов к экзаменам.
прилагательное:требовательный{}, // Он очень требователен к себе.
прилагательное:жадный{}, // Он жаден к деньгам.
прилагательное:глухой{}, // Он глух к моей просьбе.
прилагательное:добрый{}, // Он добр к детям.
rus_verbs:проявлять{}, // Он всегда проявлял живой интерес к нашим делам.
rus_verbs:плыть{}, // Пароход плыл к берегу.
rus_verbs:пойти{}, // я пошел к доктору
rus_verbs:придти{}, // придти к выводу
rus_verbs:заглянуть{}, // Я заглянул к вам мимоходом.
rus_verbs:принадлежать{}, // Это существо принадлежит к разряду растений.
rus_verbs:подготавливаться{}, // Ученики подготавливаются к экзаменам.
rus_verbs:спускаться{}, // Улица круто спускается к реке.
rus_verbs:спуститься{}, // Мы спустились к реке.
rus_verbs:пустить{}, // пускать ко дну
rus_verbs:приговаривать{}, // Мы приговариваем тебя к пожизненному веселью!
rus_verbs:отойти{}, // Дом отошёл к племяннику.
rus_verbs:отходить{}, // Коля отходил ко сну.
rus_verbs:приходить{}, // местные жители к нему приходили лечиться
rus_verbs:кидаться{}, // не кидайся к столу
rus_verbs:ходить{}, // Она простудилась и сегодня ходила к врачу.
rus_verbs:закончиться{}, // Собрание закончилось к вечеру.
rus_verbs:послать{}, // Они выбрали своих депутатов и послали их к заведующему.
rus_verbs:направиться{}, // Мы сошли на берег и направились к городу.
rus_verbs:направляться{},
rus_verbs:свестись{}, // Всё свелось к нулю.
rus_verbs:прислать{}, // Пришлите кого-нибудь к ней.
rus_verbs:присылать{}, // Он присылал к должнику своих головорезов
rus_verbs:подлететь{}, // Самолёт подлетел к лесу.
rus_verbs:возвращаться{}, // он возвращается к старой работе
глагол:находиться{ вид:несоверш }, инфинитив:находиться{ вид:несоверш }, деепричастие:находясь{},
прилагательное:находившийся{}, прилагательное:находящийся{}, // Япония находится к востоку от Китая.
rus_verbs:возвращать{}, // возвращать к жизни
rus_verbs:располагать{}, // Атмосфера располагает к работе.
rus_verbs:возвратить{}, // Колокольный звон возвратил меня к прошлому.
rus_verbs:поступить{}, // К нам поступила жалоба.
rus_verbs:поступать{}, // К нам поступают жалобы.
rus_verbs:прыгнуть{}, // Белка прыгнула к дереву
rus_verbs:торопиться{}, // пассажиры торопятся к выходу
rus_verbs:поторопиться{}, // поторопитесь к выходу
rus_verbs:вернуть{}, // вернуть к активной жизни
rus_verbs:припирать{}, // припирать к стенке
rus_verbs:проваливать{}, // Проваливай ко всем чертям!
rus_verbs:вбежать{}, // Коля вбежал ко мне
rus_verbs:вбегать{}, // Коля вбегал ко мне
глагол:забегать{ вид:несоверш }, // Коля забегал ко мне
rus_verbs:постучаться{}, // Коля постучался ко мне.
rus_verbs:повести{}, // Спросил я озорного Антонио и повел его к дому
rus_verbs:понести{}, // Мы понесли кота к ветеринару
rus_verbs:принести{}, // Я принес кота к ветеринару
rus_verbs:устремиться{}, // Мы устремились к ручью.
rus_verbs:подводить{}, // Учитель подводил детей к аквариуму
rus_verbs:следовать{}, // Я получил приказ следовать к месту нового назначения.
rus_verbs:пригласить{}, // Я пригласил к себе товарищей.
rus_verbs:собираться{}, // Я собираюсь к тебе в гости.
rus_verbs:собраться{}, // Маша собралась к дантисту
rus_verbs:сходить{}, // Я схожу к врачу.
rus_verbs:идти{}, // Маша уверенно шла к Пете
rus_verbs:измениться{}, // Основные индексы рынка акций РФ почти не изменились к закрытию.
rus_verbs:отыграть{}, // Российский рынок акций отыграл падение к закрытию.
rus_verbs:заканчивать{}, // Заканчивайте к обеду
rus_verbs:обращаться{}, // Обращайтесь ко мне в любое время
rus_verbs:окончить{}, //
rus_verbs:дозвониться{}, // Я не мог к вам дозвониться.
глагол:прийти{}, инфинитив:прийти{}, // Антонио пришел к Элеонор
rus_verbs:уйти{}, // Антонио ушел к Элеонор
rus_verbs:бежать{}, // Антонио бежит к Элеонор
rus_verbs:спешить{}, // Антонио спешит к Элеонор
rus_verbs:скакать{}, // Антонио скачет к Элеонор
rus_verbs:красться{}, // Антонио крадётся к Элеонор
rus_verbs:поскакать{}, // беглецы поскакали к холмам
rus_verbs:перейти{} // Антонио перешел к Элеонор
}
fact гл_предл
{
if context { Гл_К_Дат предлог:к{} *:*{ падеж:дат } }
then return true
}
fact гл_предл
{
if context { Гл_К_Дат предлог:к{} @regex("[a-z]+[0-9]*") }
then return true
}
// для остальных падежей запрещаем.
fact гл_предл
{
if context { * предлог:к{} *:*{} }
then return false,-5
}
#endregion Предлог_К
#region Предлог_ДЛЯ
// ------------------- С ПРЕДЛОГОМ 'ДЛЯ' ----------------------
wordentry_set Гл_ДЛЯ_Род={
частица:нет{}, // для меня нет других путей.
частица:нету{},
rus_verbs:ЗАДЕРЖАТЬ{}, // полиция может задержать их для выяснения всех обстоятельств и дальнейшего опознания. (ЗАДЕРЖАТЬ)
rus_verbs:ДЕЛАТЬСЯ{}, // это делалось для людей (ДЕЛАТЬСЯ)
rus_verbs:обернуться{}, // обернулась для греческого рынка труда банкротствами предприятий и масштабными сокращениями (обернуться)
rus_verbs:ПРЕДНАЗНАЧАТЬСЯ{}, // Скорее всего тяжелый клинок вообще не предназначался для бросков (ПРЕДНАЗНАЧАТЬСЯ)
rus_verbs:ПОЛУЧИТЬ{}, // ты можешь получить его для нас? (ПОЛУЧИТЬ)
rus_verbs:ПРИДУМАТЬ{}, // Ваш босс уже придумал для нас веселенькую смерть. (ПРИДУМАТЬ)
rus_verbs:оказаться{}, // это оказалось для них тяжелой задачей
rus_verbs:ГОВОРИТЬ{}, // теперь она говорила для нас обоих (ГОВОРИТЬ)
rus_verbs:ОСВОБОДИТЬ{}, // освободить ее для тебя? (ОСВОБОДИТЬ)
rus_verbs:работать{}, // Мы работаем для тех, кто ценит удобство
rus_verbs:СТАТЬ{}, // кем она станет для него? (СТАТЬ)
rus_verbs:ЯВИТЬСЯ{}, // вы для этого явились сюда? (ЯВИТЬСЯ)
rus_verbs:ПОТЕРЯТЬ{}, // жизнь потеряла для меня всякий смысл (ПОТЕРЯТЬ)
rus_verbs:УТРАТИТЬ{}, // мой мир утратил для меня всякое подобие смысла (УТРАТИТЬ)
rus_verbs:ДОСТАТЬ{}, // ты должен достать ее для меня! (ДОСТАТЬ)
rus_verbs:БРАТЬ{}, // некоторые берут для себя (БРАТЬ)
rus_verbs:ИМЕТЬ{}, // имею для вас новость (ИМЕТЬ)
rus_verbs:ЖДАТЬ{}, // тебя ждут для разговора (ЖДАТЬ)
rus_verbs:ПРОПАСТЬ{}, // совсем пропал для мира (ПРОПАСТЬ)
rus_verbs:ПОДНЯТЬ{}, // нас подняли для охоты (ПОДНЯТЬ)
rus_verbs:ОСТАНОВИТЬСЯ{}, // время остановилось для нее (ОСТАНОВИТЬСЯ)
rus_verbs:НАЧИНАТЬСЯ{}, // для него начинается новая жизнь (НАЧИНАТЬСЯ)
rus_verbs:КОНЧИТЬСЯ{}, // кончились для него эти игрушки (КОНЧИТЬСЯ)
rus_verbs:НАСТАТЬ{}, // для него настало время действовать (НАСТАТЬ)
rus_verbs:СТРОИТЬ{}, // для молодых строили новый дом (СТРОИТЬ)
rus_verbs:ВЗЯТЬ{}, // возьми для защиты этот меч (ВЗЯТЬ)
rus_verbs:ВЫЯСНИТЬ{}, // попытаюсь выяснить для вас всю цепочку (ВЫЯСНИТЬ)
rus_verbs:ПРИГОТОВИТЬ{}, // давай попробуем приготовить для них сюрприз (ПРИГОТОВИТЬ)
rus_verbs:ПОДХОДИТЬ{}, // берег моря мертвых подходил для этого идеально (ПОДХОДИТЬ)
rus_verbs:ОСТАТЬСЯ{}, // внешний вид этих тварей остался для нас загадкой (ОСТАТЬСЯ)
rus_verbs:ПРИВЕЗТИ{}, // для меня привезли пиво (ПРИВЕЗТИ)
прилагательное:ХАРАКТЕРНЫЙ{}, // Для всей территории края характерен умеренный континентальный климат (ХАРАКТЕРНЫЙ)
rus_verbs:ПРИВЕСТИ{}, // для меня белую лошадь привели (ПРИВЕСТИ ДЛЯ)
rus_verbs:ДЕРЖАТЬ{}, // их держат для суда (ДЕРЖАТЬ ДЛЯ)
rus_verbs:ПРЕДОСТАВИТЬ{}, // вьетнамец предоставил для мигрантов места проживания в ряде вологодских общежитий (ПРЕДОСТАВИТЬ ДЛЯ)
rus_verbs:ПРИДУМЫВАТЬ{}, // придумывая для этого разнообразные причины (ПРИДУМЫВАТЬ ДЛЯ)
rus_verbs:оставить{}, // или вообще решили оставить планету для себя
rus_verbs:оставлять{},
rus_verbs:ВОССТАНОВИТЬ{}, // как ты можешь восстановить это для меня? (ВОССТАНОВИТЬ ДЛЯ)
rus_verbs:ТАНЦЕВАТЬ{}, // а вы танцевали для меня танец семи покрывал (ТАНЦЕВАТЬ ДЛЯ)
rus_verbs:ДАТЬ{}, // твой принц дал мне это для тебя! (ДАТЬ ДЛЯ)
rus_verbs:ВОСПОЛЬЗОВАТЬСЯ{}, // мужчина из лагеря решил воспользоваться для передвижения рекой (ВОСПОЛЬЗОВАТЬСЯ ДЛЯ)
rus_verbs:СЛУЖИТЬ{}, // они служили для разговоров (СЛУЖИТЬ ДЛЯ)
rus_verbs:ИСПОЛЬЗОВАТЬСЯ{}, // Для вычисления радиуса поражения ядерных взрывов используется формула (ИСПОЛЬЗОВАТЬСЯ ДЛЯ)
rus_verbs:ПРИМЕНЯТЬСЯ{}, // Применяется для изготовления алкогольных коктейлей (ПРИМЕНЯТЬСЯ ДЛЯ)
rus_verbs:СОВЕРШАТЬСЯ{}, // Для этого совершался специальный магический обряд (СОВЕРШАТЬСЯ ДЛЯ)
rus_verbs:ПРИМЕНИТЬ{}, // а здесь попробуем применить ее для других целей. (ПРИМЕНИТЬ ДЛЯ)
rus_verbs:ПОЗВАТЬ{}, // ты позвал меня для настоящей работы. (ПОЗВАТЬ ДЛЯ)
rus_verbs:НАЧАТЬСЯ{}, // очередной денек начался для Любки неудачно (НАЧАТЬСЯ ДЛЯ)
rus_verbs:ПОСТАВИТЬ{}, // вас здесь для красоты поставили? (ПОСТАВИТЬ ДЛЯ)
rus_verbs:умереть{}, // или умерла для всяких чувств? (умереть для)
rus_verbs:ВЫБРАТЬ{}, // ты сам выбрал для себя этот путь. (ВЫБРАТЬ ДЛЯ)
rus_verbs:ОТМЕТИТЬ{}, // тот же отметил для себя другое. (ОТМЕТИТЬ ДЛЯ)
rus_verbs:УСТРОИТЬ{}, // мы хотим устроить для них школу. (УСТРОИТЬ ДЛЯ)
rus_verbs:БЫТЬ{}, // у меня есть для тебя работа. (БЫТЬ ДЛЯ)
rus_verbs:ВЫЙТИ{}, // для всего нашего поколения так вышло. (ВЫЙТИ ДЛЯ)
прилагательное:ВАЖНЫЙ{}, // именно твое мнение для нас крайне важно. (ВАЖНЫЙ ДЛЯ)
прилагательное:НУЖНЫЙ{}, // для любого племени нужна прежде всего сила. (НУЖЕН ДЛЯ)
прилагательное:ДОРОГОЙ{}, // эти места были дороги для них обоих. (ДОРОГОЙ ДЛЯ)
rus_verbs:НАСТУПИТЬ{}, // теперь для больших людей наступило время действий. (НАСТУПИТЬ ДЛЯ)
rus_verbs:ДАВАТЬ{}, // старый пень давал для этого хороший огонь. (ДАВАТЬ ДЛЯ)
rus_verbs:ГОДИТЬСЯ{}, // доброе старое время годится лишь для воспоминаний. (ГОДИТЬСЯ ДЛЯ)
rus_verbs:ТЕРЯТЬ{}, // время просто теряет для вас всякое значение. (ТЕРЯТЬ ДЛЯ)
rus_verbs:ЖЕНИТЬСЯ{}, // настало время жениться для пользы твоего клана. (ЖЕНИТЬСЯ ДЛЯ)
rus_verbs:СУЩЕСТВОВАТЬ{}, // весь мир перестал существовать для них обоих. (СУЩЕСТВОВАТЬ ДЛЯ)
rus_verbs:ЖИТЬ{}, // жить для себя или жить для них. (ЖИТЬ ДЛЯ)
rus_verbs:открыть{}, // двери моего дома всегда открыты для вас. (ОТКРЫТЫЙ ДЛЯ)
rus_verbs:закрыть{}, // этот мир будет закрыт для них. (ЗАКРЫТЫЙ ДЛЯ)
rus_verbs:ТРЕБОВАТЬСЯ{}, // для этого требуется огромное количество энергии. (ТРЕБОВАТЬСЯ ДЛЯ)
rus_verbs:РАЗОРВАТЬ{}, // Алексей разорвал для этого свою рубаху. (РАЗОРВАТЬ ДЛЯ)
rus_verbs:ПОДОЙТИ{}, // вполне подойдет для начала нашей экспедиции. (ПОДОЙТИ ДЛЯ)
прилагательное:опасный{}, // сильный холод опасен для открытой раны. (ОПАСЕН ДЛЯ)
rus_verbs:ПРИЙТИ{}, // для вас пришло очень важное сообщение. (ПРИЙТИ ДЛЯ)
rus_verbs:вывести{}, // мы специально вывели этих животных для мяса.
rus_verbs:убрать{}, // В вагонах метро для комфорта пассажиров уберут сиденья (УБРАТЬ В, ДЛЯ)
rus_verbs:оставаться{}, // механизм этого воздействия остается для меня загадкой. (остается для)
rus_verbs:ЯВЛЯТЬСЯ{}, // Чай является для китайцев обычным ежедневным напитком (ЯВЛЯТЬСЯ ДЛЯ)
rus_verbs:ПРИМЕНЯТЬ{}, // Для оценок будущих изменений климата применяют модели общей циркуляции атмосферы. (ПРИМЕНЯТЬ ДЛЯ)
rus_verbs:ПОВТОРЯТЬ{}, // повторяю для Пети (ПОВТОРЯТЬ ДЛЯ)
rus_verbs:УПОТРЕБЛЯТЬ{}, // Краски, употребляемые для живописи (УПОТРЕБЛЯТЬ ДЛЯ)
rus_verbs:ВВЕСТИ{}, // Для злостных нарушителей предложили ввести повышенные штрафы (ВВЕСТИ ДЛЯ)
rus_verbs:найтись{}, // у вас найдется для него работа?
rus_verbs:заниматься{}, // они занимаются этим для развлечения. (заниматься для)
rus_verbs:заехать{}, // Коля заехал для обсуждения проекта
rus_verbs:созреть{}, // созреть для побега
rus_verbs:наметить{}, // наметить для проверки
rus_verbs:уяснить{}, // уяснить для себя
rus_verbs:нанимать{}, // нанимать для разовой работы
rus_verbs:приспособить{}, // приспособить для удовольствия
rus_verbs:облюбовать{}, // облюбовать для посиделок
rus_verbs:прояснить{}, // прояснить для себя
rus_verbs:задействовать{}, // задействовать для патрулирования
rus_verbs:приготовлять{}, // приготовлять для проверки
инфинитив:использовать{ вид:соверш }, // использовать для достижения цели
инфинитив:использовать{ вид:несоверш },
глагол:использовать{ вид:соверш },
глагол:использовать{ вид:несоверш },
прилагательное:использованный{},
деепричастие:используя{},
деепричастие:использовав{},
rus_verbs:напрячься{}, // напрячься для решительного рывка
rus_verbs:одобрить{}, // одобрить для использования
rus_verbs:одобрять{}, // одобрять для использования
rus_verbs:пригодиться{}, // пригодиться для тестирования
rus_verbs:готовить{}, // готовить для выхода в свет
rus_verbs:отобрать{}, // отобрать для участия в конкурсе
rus_verbs:потребоваться{}, // потребоваться для подтверждения
rus_verbs:пояснить{}, // пояснить для слушателей
rus_verbs:пояснять{}, // пояснить для экзаменаторов
rus_verbs:понадобиться{}, // понадобиться для обоснования
инфинитив:адаптировать{вид:несоверш}, // машина была адаптирована для условий крайнего севера
инфинитив:адаптировать{вид:соверш},
глагол:адаптировать{вид:несоверш},
глагол:адаптировать{вид:соверш},
деепричастие:адаптировав{},
деепричастие:адаптируя{},
прилагательное:адаптирующий{},
прилагательное:адаптировавший{ вид:соверш },
//+прилагательное:адаптировавший{ вид:несоверш },
прилагательное:адаптированный{},
rus_verbs:найти{}, // Папа нашел для детей няню
прилагательное:вредный{}, // Это вредно для здоровья.
прилагательное:полезный{}, // Прогулки полезны для здоровья.
прилагательное:обязательный{}, // Этот пункт обязателен для исполнения
прилагательное:бесполезный{}, // Это лекарство бесполезно для него
прилагательное:необходимый{}, // Это лекарство необходимо для выздоровления
rus_verbs:создать{}, // Он не создан для этого дела.
прилагательное:сложный{}, // задача сложна для младших школьников
прилагательное:несложный{},
прилагательное:лёгкий{},
прилагательное:сложноватый{},
rus_verbs:становиться{},
rus_verbs:представлять{}, // Это не представляет для меня интереса.
rus_verbs:значить{}, // Я рос в деревне и хорошо знал, что для деревенской жизни значат пруд или речка
rus_verbs:пройти{}, // День прошёл спокойно для него.
rus_verbs:проходить{},
rus_verbs:высадиться{}, // большой злой пират и его отчаянные помощники высадились на необитаемом острове для поиска зарытых сокровищ
rus_verbs:высаживаться{},
rus_verbs:прибавлять{}, // Он любит прибавлять для красного словца.
rus_verbs:прибавить{},
rus_verbs:составить{}, // Ряд тригонометрических таблиц был составлен для астрономических расчётов.
rus_verbs:составлять{},
rus_verbs:стараться{}, // Я старался для вас
rus_verbs:постараться{}, // Я постарался для вас
rus_verbs:сохраниться{}, // Старик хорошо сохранился для своего возраста.
rus_verbs:собраться{}, // собраться для обсуждения
rus_verbs:собираться{}, // собираться для обсуждения
rus_verbs:уполномочивать{},
rus_verbs:уполномочить{}, // его уполномочили для ведения переговоров
rus_verbs:принести{}, // Я принёс эту книгу для вас.
rus_verbs:делать{}, // Я это делаю для удовольствия.
rus_verbs:сделать{}, // Я сделаю это для удовольствия.
rus_verbs:подготовить{}, // я подготовил для друзей сюрприз
rus_verbs:подготавливать{}, // я подготавливаю для гостей новый сюрприз
rus_verbs:закупить{}, // Руководство района обещало закупить новые комбайны для нашего села
rus_verbs:купить{}, // Руководство района обещало купить новые комбайны для нашего села
rus_verbs:прибыть{} // они прибыли для участия
}
fact гл_предл
{
if context { Гл_ДЛЯ_Род предлог:для{} *:*{ падеж:род } }
then return true
}
fact гл_предл
{
if context { Гл_ДЛЯ_Род предлог:для{} @regex("[a-z]+[0-9]*") }
then return true
}
// для остальных падежей запрещаем.
fact гл_предл
{
if context { * предлог:для{} *:*{} }
then return false,-4
}
#endregion Предлог_ДЛЯ
#region Предлог_ОТ
// попробуем иную стратегию - запретить связывание с ОТ для отдельных глаголов, разрешив для всех остальных.
wordentry_set Глаг_ОТ_Род_Запр=
{
rus_verbs:наслаждаться{}, // свободой от обязательств
rus_verbs:насладиться{},
rus_verbs:мочь{}, // Он не мог удержаться от смеха.
// rus_verbs:хотеть{},
rus_verbs:желать{},
rus_verbs:чувствовать{}, // все время от времени чувствуют его.
rus_verbs:планировать{},
rus_verbs:приняться{} // мы принялись обниматься от радости.
}
fact гл_предл
{
if context { Глаг_ОТ_Род_Запр предлог:от{} * }
then return false
}
#endregion Предлог_ОТ
#region Предлог_БЕЗ
/*
// запретить связывание с БЕЗ для отдельных глаголов, разрешив для всех остальных.
wordentry_set Глаг_БЕЗ_Род_Запр=
{
rus_verbs:мочь{}, // Он мог читать часами без отдыха.
rus_verbs:хотеть{},
rus_verbs:желать{},
rus_verbs:планировать{},
rus_verbs:приняться{}
}
fact гл_предл
{
if context { Глаг_БЕЗ_Род_Запр предлог:без{} * }
then return false
}
*/
#endregion Предлог_БЕЗ
#region Предлог_КРОМЕ
fact гл_предл
{
if context { * ПредлогДляВсе * }
then return false,-5
}
#endregion Предлог_КРОМЕ
// ------------------------------------
// По умолчанию разрешаем все остальные сочетания.
fact гл_предл
{
if context { * * * }
then return true
}
| водрузить флаг на флагшток
| rus_verbs:водрузить{}, | 5,486,094 | [
1,
145,
115,
145,
127,
145,
117,
146,
227,
146,
230,
145,
120,
145,
121,
146,
229,
146,
239,
225,
146,
231,
145,
124,
145,
113,
145,
116,
225,
145,
126,
145,
113,
225,
146,
231,
145,
124,
145,
113,
145,
116,
146,
235,
146,
229,
145,
127,
145,
123,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
8010,
67,
502,
2038,
30,
145,
115,
145,
127,
145,
117,
146,
227,
146,
230,
145,
120,
145,
121,
146,
229,
146,
239,
2916,
16,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
/**
*Submitted for verification at Etherscan.io on 2021-01-13
*/
pragma solidity >=0.7.5;
// SPDX-License-Identifier: BSD-3-Clause
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract YFTE_Farming1 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
event RewardsDisbursed(uint amount);
// Uniswap WETH/YFTE LP token contract address
address public constant LPtokenAddress = 0x2dc9136aCE4077D5060131c0ecCD1635897c75dD;
//YFTE token address
address public constant tokenAddress = 0x94F31aC896c9823D81cf9C2C93feCEeD4923218f;
uint public constant withdrawFeePercentX100 = 50;
uint public constant disburseAmount = 200e18;
uint public constant disburseDuration = 30 days;
uint public disbursePercentX100 = 10000;
uint public lastDisburseTime;
constructor() {
lastDisburseTime = block.timestamp;
}
uint public totalClaimedRewards = 0;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public depositTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
mapping (address => uint) public lastDivPoints;
uint public totalTokensDisbursed = 0;
uint public contractBalance = 0;
uint public totalDivPoints = 0;
uint public totalTokens = 0;
uint internal pointMultiplier = 1e18;
function addContractBalance(uint amount) public onlyOwner {
require(Token(tokenAddress).transferFrom(msg.sender, address(this), amount), "Cannot add balance!");
contractBalance = contractBalance.add(amount);
}
function updateAccount(address account) private {
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
require(Token(tokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = block.timestamp;
lastDivPoints[account] = totalDivPoints;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint newDivPoints = totalDivPoints.sub(lastDivPoints[_holder]);
uint depositedAmount = depositedTokens[_holder];
uint pendingDivs = depositedAmount.mul(newDivPoints).div(pointMultiplier);
return pendingDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function deposit(uint amountToDeposit) public {
require(amountToDeposit > 0, "Cannot deposit 0 Tokens");
updateAccount(msg.sender);
require(Token(LPtokenAddress).transferFrom(msg.sender, address(this), amountToDeposit), "Insufficient Token Allowance");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToDeposit);
totalTokens = totalTokens.add(amountToDeposit);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
depositTime[msg.sender] = block.timestamp;
}
}
function withdraw(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(withdrawFeePercentX100).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(LPtokenAddress).transfer(owner, fee), "Could not transfer fee!");
require(Token(LPtokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function emergencyWithdraw(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
lastClaimedTime[msg.sender] = block.timestamp;
lastDivPoints[msg.sender] = totalDivPoints;
uint fee = amountToWithdraw.mul(withdrawFeePercentX100).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(LPtokenAddress).transfer(owner, fee), "Could not transfer fee!");
require(Token(LPtokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claim() public {
updateAccount(msg.sender);
}
function distributeDivs(uint amount) private {
if (totalTokens == 0) return;
totalDivPoints = totalDivPoints.add(amount.mul(pointMultiplier).div(totalTokens));
emit RewardsDisbursed(amount);
}
function disburseTokens() public onlyOwner {
uint amount = getPendingDisbursement();
// uint contractBalance = Token(tokenAddress).balanceOf(address(this));
if (contractBalance < amount) {
amount = contractBalance;
}
if (amount == 0) return;
distributeDivs(amount);
contractBalance = contractBalance.sub(amount);
lastDisburseTime = block.timestamp;
}
function getPendingDisbursement() public view returns (uint) {
uint timeDiff = block.timestamp.sub(lastDisburseTime);
uint pendingDisburse = disburseAmount
.mul(disbursePercentX100)
.mul(timeDiff)
.div(disburseDuration)
.div(10000);
return pendingDisburse;
}
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
/* function to allow owner to claim *other* ERC20 tokens sent to this contract.
Owner cannot recover unclaimed tokens (they are burnt)
*/
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
// require(_tokenAddr != tokenAddress && _tokenAddr != LPtokenAddress, "Cannot send out reward tokens or LP tokens!");
require(_tokenAddr != LPtokenAddress, "Admin cannot transfer out LP tokens from this vault!");
require(_tokenAddr != tokenAddress , "Admin cannot Transfer out Reward Tokens from this vault!");
Token(_tokenAddr).transfer(_to, _amount);
}
} | Uniswap WETH/YFTE LP token contract addressYFTE token address | contract YFTE_Farming1 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
event RewardsDisbursed(uint amount);
address public constant LPtokenAddress = 0x2dc9136aCE4077D5060131c0ecCD1635897c75dD;
address public constant tokenAddress = 0x94F31aC896c9823D81cf9C2C93feCEeD4923218f;
uint public constant withdrawFeePercentX100 = 50;
uint public constant disburseAmount = 200e18;
uint public constant disburseDuration = 30 days;
uint public disbursePercentX100 = 10000;
uint public lastDisburseTime;
constructor() {
lastDisburseTime = block.timestamp;
}
uint public totalClaimedRewards = 0;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public depositTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
mapping (address => uint) public lastDivPoints;
uint public totalTokensDisbursed = 0;
uint public contractBalance = 0;
uint public totalDivPoints = 0;
uint public totalTokens = 0;
uint internal pointMultiplier = 1e18;
function addContractBalance(uint amount) public onlyOwner {
require(Token(tokenAddress).transferFrom(msg.sender, address(this), amount), "Cannot add balance!");
contractBalance = contractBalance.add(amount);
}
function updateAccount(address account) private {
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
require(Token(tokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = block.timestamp;
lastDivPoints[account] = totalDivPoints;
}
function updateAccount(address account) private {
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
require(Token(tokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = block.timestamp;
lastDivPoints[account] = totalDivPoints;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint newDivPoints = totalDivPoints.sub(lastDivPoints[_holder]);
uint depositedAmount = depositedTokens[_holder];
uint pendingDivs = depositedAmount.mul(newDivPoints).div(pointMultiplier);
return pendingDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function deposit(uint amountToDeposit) public {
require(amountToDeposit > 0, "Cannot deposit 0 Tokens");
updateAccount(msg.sender);
require(Token(LPtokenAddress).transferFrom(msg.sender, address(this), amountToDeposit), "Insufficient Token Allowance");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToDeposit);
totalTokens = totalTokens.add(amountToDeposit);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
depositTime[msg.sender] = block.timestamp;
}
}
function deposit(uint amountToDeposit) public {
require(amountToDeposit > 0, "Cannot deposit 0 Tokens");
updateAccount(msg.sender);
require(Token(LPtokenAddress).transferFrom(msg.sender, address(this), amountToDeposit), "Insufficient Token Allowance");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToDeposit);
totalTokens = totalTokens.add(amountToDeposit);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
depositTime[msg.sender] = block.timestamp;
}
}
function withdraw(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(withdrawFeePercentX100).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(LPtokenAddress).transfer(owner, fee), "Could not transfer fee!");
require(Token(LPtokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function withdraw(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(withdrawFeePercentX100).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(LPtokenAddress).transfer(owner, fee), "Could not transfer fee!");
require(Token(LPtokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function emergencyWithdraw(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
lastClaimedTime[msg.sender] = block.timestamp;
lastDivPoints[msg.sender] = totalDivPoints;
uint fee = amountToWithdraw.mul(withdrawFeePercentX100).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(LPtokenAddress).transfer(owner, fee), "Could not transfer fee!");
require(Token(LPtokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function emergencyWithdraw(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
lastClaimedTime[msg.sender] = block.timestamp;
lastDivPoints[msg.sender] = totalDivPoints;
uint fee = amountToWithdraw.mul(withdrawFeePercentX100).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(LPtokenAddress).transfer(owner, fee), "Could not transfer fee!");
require(Token(LPtokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claim() public {
updateAccount(msg.sender);
}
function distributeDivs(uint amount) private {
if (totalTokens == 0) return;
totalDivPoints = totalDivPoints.add(amount.mul(pointMultiplier).div(totalTokens));
emit RewardsDisbursed(amount);
}
function disburseTokens() public onlyOwner {
uint amount = getPendingDisbursement();
if (contractBalance < amount) {
amount = contractBalance;
}
if (amount == 0) return;
distributeDivs(amount);
contractBalance = contractBalance.sub(amount);
lastDisburseTime = block.timestamp;
}
function disburseTokens() public onlyOwner {
uint amount = getPendingDisbursement();
if (contractBalance < amount) {
amount = contractBalance;
}
if (amount == 0) return;
distributeDivs(amount);
contractBalance = contractBalance.sub(amount);
lastDisburseTime = block.timestamp;
}
function getPendingDisbursement() public view returns (uint) {
uint timeDiff = block.timestamp.sub(lastDisburseTime);
uint pendingDisburse = disburseAmount
.mul(disbursePercentX100)
.mul(timeDiff)
.div(disburseDuration)
.div(10000);
return pendingDisburse;
}
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
Owner cannot recover unclaimed tokens (they are burnt)
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
require(_tokenAddr != LPtokenAddress, "Admin cannot transfer out LP tokens from this vault!");
require(_tokenAddr != tokenAddress , "Admin cannot Transfer out Reward Tokens from this vault!");
Token(_tokenAddr).transfer(_to, _amount);
}
} | 8,029,967 | [
1,
984,
291,
91,
438,
678,
1584,
44,
19,
61,
42,
1448,
511,
52,
1147,
6835,
1758,
61,
42,
1448,
1147,
1758,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
1624,
42,
1448,
67,
42,
4610,
310,
21,
353,
14223,
6914,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
31,
203,
565,
1450,
6057,
25121,
694,
364,
6057,
25121,
694,
18,
1887,
694,
31,
203,
377,
203,
565,
871,
534,
359,
14727,
1429,
4193,
12,
2867,
10438,
16,
2254,
3844,
1769,
203,
565,
871,
534,
359,
14727,
1669,
70,
295,
730,
12,
11890,
3844,
1769,
203,
377,
203,
565,
1758,
1071,
5381,
511,
52,
2316,
1887,
273,
374,
92,
22,
7201,
29,
26959,
69,
1441,
7132,
4700,
40,
3361,
26,
1611,
6938,
71,
20,
557,
10160,
2313,
4763,
6675,
27,
71,
5877,
72,
40,
31,
203,
565,
1758,
1071,
5381,
1147,
1887,
273,
374,
92,
11290,
42,
6938,
69,
39,
6675,
26,
71,
10689,
4366,
40,
11861,
8522,
29,
39,
22,
39,
11180,
3030,
1441,
73,
40,
7616,
22,
1578,
2643,
74,
31,
7010,
565,
2254,
1071,
5381,
598,
9446,
14667,
8410,
60,
6625,
273,
6437,
31,
203,
565,
2254,
1071,
5381,
1015,
70,
295,
307,
6275,
273,
4044,
73,
2643,
31,
203,
565,
2254,
1071,
5381,
1015,
70,
295,
307,
5326,
273,
5196,
4681,
31,
203,
377,
203,
377,
203,
565,
2254,
1071,
1015,
70,
295,
307,
8410,
60,
6625,
273,
12619,
31,
203,
377,
203,
565,
2254,
1071,
1142,
1669,
70,
295,
307,
950,
31,
203,
377,
203,
565,
3885,
1435,
225,
288,
203,
3639,
1142,
1669,
70,
295,
307,
950,
273,
1203,
18,
5508,
31,
203,
565,
289,
203,
203,
377,
203,
565,
2254,
1071,
2078,
9762,
329,
17631,
14727,
2
]
|
./full_match/80001/0xeecCE59925A706b2450b604b2F7f49e9f1c5F41d/sources/project_/contracts/proxy/IdentityRegistryProxy.sol | solhint-disable-next-line avoid-low-level-calls | ) {
require(
implementationAuthority != address(0)
&& _trustedIssuersRegistry != address(0)
&& _claimTopicsRegistry != address(0)
&& _identityStorage != address(0)
, "invalid argument - zero address");
_implementationAuthority = implementationAuthority;
emit ImplementationAuthoritySet( implementationAuthority);
address logic = (ITREXImplementationAuthority(_implementationAuthority)).getIRImplementation();
(bool success, ) = logic.delegatecall(
abi.encodeWithSignature(
"init(address,address,address)",
_trustedIssuersRegistry,
_claimTopicsRegistry,
_identityStorage));
require(success, "Initialization failed.");
}
| 845,018 | [
1,
18281,
11317,
17,
8394,
17,
4285,
17,
1369,
4543,
17,
821,
17,
2815,
17,
12550,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
262,
288,
203,
3639,
2583,
12,
203,
3639,
4471,
10962,
480,
1758,
12,
20,
13,
203,
3639,
597,
389,
25247,
7568,
27307,
4243,
480,
1758,
12,
20,
13,
203,
3639,
597,
389,
14784,
17477,
4243,
480,
1758,
12,
20,
13,
203,
3639,
597,
389,
10781,
3245,
480,
1758,
12,
20,
13,
203,
3639,
269,
315,
5387,
1237,
300,
3634,
1758,
8863,
203,
3639,
389,
30810,
10962,
273,
4471,
10962,
31,
203,
3639,
3626,
25379,
10962,
694,
12,
4471,
10962,
1769,
203,
203,
3639,
1758,
4058,
273,
261,
1285,
862,
60,
13621,
10962,
24899,
30810,
10962,
13,
2934,
588,
7937,
13621,
5621,
203,
203,
3639,
261,
6430,
2216,
16,
262,
273,
4058,
18,
22216,
1991,
12,
203,
5411,
24126,
18,
3015,
1190,
5374,
12,
203,
10792,
315,
2738,
12,
2867,
16,
2867,
16,
2867,
2225,
16,
203,
10792,
389,
25247,
7568,
27307,
4243,
16,
203,
10792,
389,
14784,
17477,
4243,
16,
203,
10792,
389,
10781,
3245,
10019,
203,
3639,
2583,
12,
4768,
16,
315,
17701,
2535,
1199,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/80001/0x7F6Df5eC4e5cd460E3BBF354b3EbbceEc2949585/sources/masterchef.sol | MasterChef is the master of CNT. He can make CNT and he is a fair guy. Note that it's ownable and the owner wields tremendous power. The ownership will be transferred to a governance smart contract once CNT is sufficiently distributed and the community can show to govern itself. Have fun reading it. Hopefully it's bug-free. God bless. Info of each user. | contract MasterChef is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct UserInfo {
}
struct PoolInfo {
}
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
CryptionNetworkToken _cnt,
uint256 _cntPerBlock,
uint256 _startBlock,
uint256 _bonusEndBlock
CryptionNetworkToken public cnt;
uint256 public bonusEndBlock;
uint256 public cntPerBlock;
uint256 public BONUS_MULTIPLIER = 1;
IMigratorChef public migrator;
PoolInfo[] public poolInfo;
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
uint256 public totalAllocPoint = 0;
uint256 public startBlock;
) public {
cnt = _cnt;
cntPerBlock = _cntPerBlock;
startBlock = _startBlock;
bonusEndBlock = _bonusEndBlock;
}
function updateBonusMultiplier(uint256 multiplierNumber) public onlyOwner {
BONUS_MULTIPLIER = multiplierNumber;
}
function updateBlockRate(uint256 _cntPerBlock) external onlyOwner {
cntPerBlock = _cntPerBlock;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accCNTPerShare: 0
}));
}
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accCNTPerShare: 0
}));
}
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accCNTPerShare: 0
}));
}
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
function setMigrator(IMigratorChef _migrator) public onlyOwner {
migrator = _migrator;
}
function migrate(uint256 _pid) public {
require(address(migrator) != address(0), "migrate: no migrator");
PoolInfo storage pool = poolInfo[_pid];
IERC20 lpToken = pool.lpToken;
uint256 bal = lpToken.balanceOf(address(this));
lpToken.safeApprove(address(migrator), bal);
IERC20 newLpToken = migrator.migrate(lpToken);
require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
pool.lpToken = newLpToken;
}
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
return _to.sub(_from).mul(BONUS_MULTIPLIER);
}
function pendingCNT(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accCNTPerShare = pool.accCNTPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 cntReward = multiplier.mul(cntPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accCNTPerShare = accCNTPerShare.add(cntReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accCNTPerShare).div(1e12).sub(user.rewardDebt);
}
function pendingCNT(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accCNTPerShare = pool.accCNTPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 cntReward = multiplier.mul(cntPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accCNTPerShare = accCNTPerShare.add(cntReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accCNTPerShare).div(1e12).sub(user.rewardDebt);
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 cntReward = multiplier.mul(cntPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pool.accCNTPerShare = pool.accCNTPerShare.add(cntReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 cntReward = multiplier.mul(cntPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pool.accCNTPerShare = pool.accCNTPerShare.add(cntReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 cntReward = multiplier.mul(cntPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pool.accCNTPerShare = pool.accCNTPerShare.add(cntReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
function deposit(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'deposit CNT by staking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accCNTPerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCNTTransfer(msg.sender, pending);
}
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accCNTPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
function deposit(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'deposit CNT by staking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accCNTPerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCNTTransfer(msg.sender, pending);
}
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accCNTPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
function deposit(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'deposit CNT by staking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accCNTPerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCNTTransfer(msg.sender, pending);
}
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accCNTPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
function deposit(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'deposit CNT by staking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accCNTPerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCNTTransfer(msg.sender, pending);
}
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accCNTPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'withdraw CNT by unstaking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accCNTPerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCNTTransfer(msg.sender, pending);
}
if(_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.rewardDebt = user.amount.mul(pool.accCNTPerShare).div(1e12);
emit Withdraw(msg.sender, _pid, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'withdraw CNT by unstaking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accCNTPerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCNTTransfer(msg.sender, pending);
}
if(_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.rewardDebt = user.amount.mul(pool.accCNTPerShare).div(1e12);
emit Withdraw(msg.sender, _pid, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'withdraw CNT by unstaking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accCNTPerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCNTTransfer(msg.sender, pending);
}
if(_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.rewardDebt = user.amount.mul(pool.accCNTPerShare).div(1e12);
emit Withdraw(msg.sender, _pid, _amount);
}
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
function safeCNTTransfer(address _to, uint256 _amount) internal {
uint256 cntBal = cnt.balanceOf(address(this));
if (_amount > cntBal) {
cnt.transfer(_to, cntBal);
cnt.transfer(_to, _amount);
}
}
function safeCNTTransfer(address _to, uint256 _amount) internal {
uint256 cntBal = cnt.balanceOf(address(this));
if (_amount > cntBal) {
cnt.transfer(_to, cntBal);
cnt.transfer(_to, _amount);
}
}
} else {
} | 862,752 | [
1,
7786,
39,
580,
74,
353,
326,
4171,
434,
385,
1784,
18,
8264,
848,
1221,
385,
1784,
471,
3904,
353,
279,
284,
1826,
3058,
93,
18,
3609,
716,
518,
1807,
4953,
429,
471,
326,
3410,
341,
491,
87,
268,
2764,
409,
1481,
7212,
18,
1021,
23178,
903,
506,
906,
4193,
358,
279,
314,
1643,
82,
1359,
13706,
6835,
3647,
385,
1784,
353,
18662,
715,
16859,
471,
326,
19833,
848,
2405,
358,
314,
1643,
82,
6174,
18,
21940,
9831,
6453,
518,
18,
670,
1306,
4095,
518,
1807,
7934,
17,
9156,
18,
611,
369,
324,
2656,
18,
3807,
434,
1517,
729,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
13453,
39,
580,
74,
353,
14223,
6914,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
565,
1450,
14060,
654,
39,
3462,
364,
467,
654,
39,
3462,
31,
203,
203,
565,
1958,
25003,
288,
203,
565,
289,
203,
203,
565,
1958,
8828,
966,
288,
203,
565,
289,
203,
203,
203,
203,
565,
871,
4019,
538,
305,
12,
2867,
8808,
729,
16,
2254,
5034,
8808,
4231,
16,
2254,
5034,
3844,
1769,
203,
565,
871,
3423,
9446,
12,
2867,
8808,
729,
16,
2254,
5034,
8808,
4231,
16,
2254,
5034,
3844,
1769,
203,
565,
871,
512,
6592,
75,
2075,
1190,
9446,
12,
2867,
8808,
729,
16,
2254,
5034,
8808,
4231,
16,
2254,
5034,
3844,
1769,
203,
203,
565,
3885,
12,
203,
3639,
385,
4346,
3906,
1345,
389,
13085,
16,
203,
3639,
2254,
5034,
389,
13085,
2173,
1768,
16,
203,
3639,
2254,
5034,
389,
1937,
1768,
16,
203,
3639,
2254,
5034,
389,
18688,
407,
1638,
1768,
203,
565,
385,
4346,
3906,
1345,
1071,
7599,
31,
203,
565,
2254,
5034,
1071,
324,
22889,
1638,
1768,
31,
203,
565,
2254,
5034,
1071,
7599,
2173,
1768,
31,
203,
565,
2254,
5034,
1071,
605,
673,
3378,
67,
24683,
2053,
654,
273,
404,
31,
203,
565,
6246,
2757,
639,
39,
580,
74,
1071,
30188,
31,
203,
565,
8828,
966,
8526,
1071,
2845,
966,
31,
203,
565,
2874,
261,
11890,
5034,
516,
2874,
261,
2867,
516,
25003,
3719,
1071,
16753,
31,
203,
565,
2254,
5034,
1071,
2078,
8763,
2148,
273,
374,
31,
203,
565,
2254,
5034,
1071,
787,
1768,
31,
203,
2
]
|
/**
*Submitted for verification at Etherscan.io on 2021-02-11
*/
pragma solidity ^0.4.24;
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
//if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
//name this contract whatever you'd like
contract ERC20Token is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
string public symbol; //An identifier: eg SBX
string public version = 'H1.0'; //human 0.1 standard. Just an arbitrary versioning scheme.
//
// CHANGE THESE VALUES FOR YOUR TOKEN
//
//make sure this function name matches the contract name above. So if you're token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Token
function ERC20Token(
) {
balances[msg.sender] = 156953087406668000000000000000000000000000; // Give the creator all initial tokens (100000 for example)
totalSupply = 156953087406668000000000000000000000000000; // Update total supply (100000 for example)
name = "TIKTOK COIN"; // Set the name for display purposes
decimals = 0; // Amount of decimals for display purposes
symbol = "TIKTOK"; // Set the symbol for display purposes
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | human 0.1 standard. Just an arbitrary versioning scheme.
| string public version = 'H1.0'; | 1,994,525 | [
1,
24270,
374,
18,
21,
4529,
18,
12526,
392,
11078,
1177,
310,
4355,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
282,
533,
1071,
1177,
273,
296,
44,
21,
18,
20,
13506,
3639,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/4/0x057286640E343Ad8977C710e45f39d12Ef46f668/sources/contracts/CryptoColorToken.sol | * Mints Crypto Color Token Assets/ | function mintToken(uint numberOfTokens) public payable {
require(saleIsActive, "Sale must be active to mint Token");
require(numberOfTokens <= maxTokenPurchase, "Can only mint 20 tokens at a time");
require(totalSupply().add(numberOfTokens) <= MAX_TOKENS, "Purchase would exceed max supply of Tokens");
require(tokenPrice.mul(numberOfTokens) <= msg.value, "Ether value sent is not correct");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply();
if (totalSupply() < MAX_TOKENS) {
_safeMint(msg.sender, mintIndex);
}
}
}
| 679,470 | [
1,
49,
28142,
15629,
5563,
3155,
26284,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
312,
474,
1345,
12,
11890,
7922,
5157,
13,
1071,
8843,
429,
288,
203,
3639,
2583,
12,
87,
5349,
2520,
3896,
16,
315,
30746,
1297,
506,
2695,
358,
312,
474,
3155,
8863,
203,
3639,
2583,
12,
2696,
951,
5157,
1648,
943,
1345,
23164,
16,
315,
2568,
1338,
312,
474,
4200,
2430,
622,
279,
813,
8863,
203,
3639,
2583,
12,
4963,
3088,
1283,
7675,
1289,
12,
2696,
951,
5157,
13,
1648,
4552,
67,
8412,
55,
16,
315,
23164,
4102,
9943,
943,
14467,
434,
13899,
8863,
203,
3639,
2583,
12,
2316,
5147,
18,
16411,
12,
2696,
951,
5157,
13,
1648,
1234,
18,
1132,
16,
315,
41,
1136,
460,
3271,
353,
486,
3434,
8863,
203,
540,
203,
3639,
364,
12,
11890,
277,
273,
374,
31,
277,
411,
7922,
5157,
31,
277,
27245,
288,
203,
5411,
2254,
312,
474,
1016,
273,
2078,
3088,
1283,
5621,
203,
5411,
309,
261,
4963,
3088,
1283,
1435,
411,
4552,
67,
8412,
55,
13,
288,
203,
7734,
389,
4626,
49,
474,
12,
3576,
18,
15330,
16,
312,
474,
1016,
1769,
203,
5411,
289,
203,
3639,
289,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.7.6;
pragma abicoder v2; // solhint-disable-line
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/Exponential.sol";
import "./libraries/IterableLoanMap.sol";
import "./interfaces/IAdapter.sol";
import "./interfaces/IBtoken.sol";
import "./interfaces/IFarmingPool.sol";
import "./interfaces/ITreasuryPool.sol";
contract FarmingPool is Pausable, ReentrancyGuard, IFarmingPool {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Exponential for uint256;
using IterableLoanMap for IterableLoanMap.RateToLoanMap;
struct RepaymentDetails {
uint256 underlyingAssetInvested;
uint256 profit;
uint256 taxAmount;
uint256 depositPrincipal;
uint256 payableInterest;
uint256 loanPrincipalToRepay;
uint256 amountToReceive;
}
struct BorrowerInterestRateModel {
uint256 interestRateIntegerPoint1; // as percentage in unsigned integer
uint256 interestRateIntegerPoint2; // as percentage in unsigned integer
uint256 utilisationRatePoint1; // as percentage in unsigned 64.64 fixed-point number
uint256 utilisationRatePoint2; // as percentage in unsigned 64.64 fixed-point number
uint256 interestRateSlope1; // in unsigned 64.64 fixed-point number
uint256 interestRateSlope2; // in unsigned 64.64 fixed-point number
}
struct FarmingPoolConfig {
uint256 leverageFactor;
uint256 liquidationPenalty; // as percentage in unsigned integer
uint256 taxRate; // as percentage in unsigned integer
}
struct BorrowerInterestRateConfig {
uint256 integerInterestRatePoint1;
uint256 integerInterestRatePoint2;
uint256 integerUtilisationRatePoint1;
uint256 integerUtilisationRatePoint2;
}
uint256 public constant ROUNDING_TOLERANCE = 9999999999 wei;
uint256 public constant NUM_FRACTION_BITS = 64;
uint256 public constant SECONDS_IN_DAY = 86400;
uint256 public constant DAYS_IN_YEAR = 365;
uint256 public constant SECONDS_IN_YEAR = SECONDS_IN_DAY * DAYS_IN_YEAR;
uint256 public constant PERCENT_100 = 100;
string public name;
address public governanceAccount;
address public underlyingAssetAddress;
address public btokenAddress;
address public treasuryPoolAddress;
address public insuranceFundAddress;
address public adapterAddress;
uint256 public totalUnderlyingAsset;
uint256 public totalInterestEarned;
FarmingPoolConfig private _farmingPoolConfig;
BorrowerInterestRateModel private _borrowerInterestRateModel;
mapping(address => uint256) private _totalTransferToAdapter;
mapping(address => IterableLoanMap.RateToLoanMap) private _farmerLoans;
IterableLoanMap.RateToLoanMap private _poolLoans;
constructor(
string memory name_,
address underlyingAssetAddress_,
address btokenAddress_,
address treasuryPoolAddress_,
address insuranceFundAddress_,
uint256 leverageFactor_,
uint256 liquidationPenalty_,
uint256 taxRate_,
BorrowerInterestRateConfig memory browserInterestRateConfig_
) {
require(
underlyingAssetAddress_ != address(0),
"0 underlying asset address"
);
require(btokenAddress_ != address(0), "0 BToken address");
require(treasuryPoolAddress_ != address(0), "0 treasury pool address");
require(
insuranceFundAddress_ != address(0),
"0 insurance fund address"
);
require(leverageFactor_ >= 1, "leverage factor < 1");
require(liquidationPenalty_ <= 100, "liquidation penalty > 100%");
require(taxRate_ <= 100, "tax rate > 100%");
name = name_;
governanceAccount = msg.sender;
underlyingAssetAddress = underlyingAssetAddress_;
btokenAddress = btokenAddress_;
treasuryPoolAddress = treasuryPoolAddress_;
insuranceFundAddress = insuranceFundAddress_;
_farmingPoolConfig.leverageFactor = leverageFactor_;
_farmingPoolConfig.liquidationPenalty = liquidationPenalty_;
_farmingPoolConfig.taxRate = taxRate_;
_borrowerInterestRateModel
.interestRateIntegerPoint1 = browserInterestRateConfig_
.integerInterestRatePoint1;
_borrowerInterestRateModel
.interestRateIntegerPoint2 = browserInterestRateConfig_
.integerInterestRatePoint2;
(
_borrowerInterestRateModel.utilisationRatePoint1,
_borrowerInterestRateModel.utilisationRatePoint2,
_borrowerInterestRateModel.interestRateSlope1,
_borrowerInterestRateModel.interestRateSlope2
) = calculateBorrowerInterestRateModel(
browserInterestRateConfig_.integerInterestRatePoint1,
browserInterestRateConfig_.integerInterestRatePoint2,
browserInterestRateConfig_.integerUtilisationRatePoint1,
browserInterestRateConfig_.integerUtilisationRatePoint2
);
}
modifier onlyBy(address account) {
require(msg.sender == account, "unauthorized");
_;
}
function addLiquidity(uint256 amount) external override nonReentrant {
require(amount > 0, "0 amount");
require(!paused(), "paused");
require(
IERC20(underlyingAssetAddress).balanceOf(msg.sender) >= amount,
"insufficient underlying asset"
);
uint256 utilisationRate =
ITreasuryPool(treasuryPoolAddress).getUtilisationRate(); // in unsigned 64.64-bit fixed point number
uint256 integerNominalAnnualRate =
getBorrowNominalAnnualRate(utilisationRate);
uint256 transferAmount = amount.mul(_farmingPoolConfig.leverageFactor);
_totalTransferToAdapter[msg.sender] = _totalTransferToAdapter[
msg.sender
]
.add(transferAmount);
uint256 loanAmount = transferAmount.sub(amount);
updateLoansForDeposit(
_farmerLoans[msg.sender],
integerNominalAnnualRate,
loanAmount
);
updateLoansForDeposit(_poolLoans, integerNominalAnnualRate, loanAmount);
totalUnderlyingAsset = totalUnderlyingAsset.add(amount);
IERC20(underlyingAssetAddress).safeTransferFrom(
msg.sender,
address(this),
amount
);
ITreasuryPool(treasuryPoolAddress).loan(loanAmount);
bool isApproved =
IERC20(underlyingAssetAddress).approve(
adapterAddress,
transferAmount
);
require(isApproved, "approve failed");
// https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3
// slither-disable-next-line reentrancy-events
uint256 receiveQuantity =
IAdapter(adapterAddress).depositUnderlyingToken(transferAmount);
emit AddLiquidity(
msg.sender,
underlyingAssetAddress,
amount,
receiveQuantity,
block.timestamp
);
IBtoken(btokenAddress).mint(msg.sender, receiveQuantity);
}
function removeLiquidity(uint256 requestedAmount)
external
override
nonReentrant
{
require(requestedAmount > 0, "0 requested amount");
require(!paused(), "paused");
(
RepaymentDetails memory repaymentDetails,
uint256 actualAmount,
uint256 receiveQuantity,
uint256 actualAmountToReceive,
uint256 outstandingInterest
) = removeLiquidityFor(msg.sender, requestedAmount);
emit RemoveLiquidity(
msg.sender,
underlyingAssetAddress,
requestedAmount,
actualAmount,
receiveQuantity,
repaymentDetails.loanPrincipalToRepay,
repaymentDetails.payableInterest,
repaymentDetails.taxAmount,
actualAmountToReceive,
outstandingInterest,
block.timestamp
);
{
// scope to avoid stack too deep errors
bool isApproved =
IERC20(underlyingAssetAddress).approve(
treasuryPoolAddress,
repaymentDetails.loanPrincipalToRepay.add(
repaymentDetails.payableInterest
)
);
require(isApproved, "approve failed");
}
ITreasuryPool(treasuryPoolAddress).repay(
repaymentDetails.loanPrincipalToRepay,
repaymentDetails.payableInterest
);
IBtoken(btokenAddress).burn(msg.sender, actualAmount);
IERC20(underlyingAssetAddress).safeTransfer(
insuranceFundAddress,
repaymentDetails.taxAmount
);
IERC20(underlyingAssetAddress).safeTransfer(
msg.sender,
actualAmountToReceive
);
}
function liquidate(address account)
external
override
nonReentrant
onlyBy(governanceAccount)
{
require(account != address(0), "0 account");
uint256 farmerBtokenBalance = IBtoken(btokenAddress).balanceOf(account);
require(farmerBtokenBalance > 0, "insufficient BToken");
(
RepaymentDetails memory repaymentDetails,
uint256 actualAmount,
uint256 receiveQuantity,
uint256 actualAmountToReceive,
uint256 outstandingInterest
) = removeLiquidityFor(account, farmerBtokenBalance);
uint256 penalty =
actualAmountToReceive
.mul(_farmingPoolConfig.liquidationPenalty)
.div(PERCENT_100);
uint256 finalAmountToReceive = actualAmountToReceive.sub(penalty);
emit LiquidateFarmer(
msg.sender,
underlyingAssetAddress,
account,
farmerBtokenBalance,
actualAmount,
receiveQuantity,
repaymentDetails.loanPrincipalToRepay,
repaymentDetails.payableInterest,
repaymentDetails.taxAmount,
penalty,
finalAmountToReceive,
outstandingInterest,
block.timestamp
);
{
// scope to avoid stack too deep errors
bool isApproved =
IERC20(underlyingAssetAddress).approve(
treasuryPoolAddress,
repaymentDetails.loanPrincipalToRepay.add(
repaymentDetails.payableInterest
)
);
require(isApproved, "approve failed");
}
ITreasuryPool(treasuryPoolAddress).repay(
repaymentDetails.loanPrincipalToRepay,
repaymentDetails.payableInterest
);
IBtoken(btokenAddress).burn(account, actualAmount);
IERC20(underlyingAssetAddress).safeTransfer(
insuranceFundAddress,
repaymentDetails.taxAmount.add(penalty)
);
IERC20(underlyingAssetAddress).safeTransfer(
account,
finalAmountToReceive
);
}
function computeBorrowerInterestEarning()
external
override
onlyBy(treasuryPoolAddress)
returns (uint256 borrowerInterestEarning)
{
require(!paused(), "paused");
(
,
uint256[] memory poolIntegerInterestRates,
IterableLoanMap.Loan[] memory poolSortedLoans
) = accrueInterestForLoan(_poolLoans);
require(
poolIntegerInterestRates.length == poolSortedLoans.length,
"pool len diff"
);
borrowerInterestEarning = getInterestEarning(poolSortedLoans);
updateLoansForPoolComputeInterest(
poolIntegerInterestRates,
poolSortedLoans
);
emit ComputeBorrowerInterestEarning(
borrowerInterestEarning,
block.timestamp
);
}
function setGovernanceAccount(address newGovernanceAccount)
external
onlyBy(governanceAccount)
{
require(newGovernanceAccount != address(0), "0 governance account");
governanceAccount = newGovernanceAccount;
}
function setTreasuryPoolAddress(address newTreasuryPoolAddress)
external
onlyBy(governanceAccount)
{
require(
newTreasuryPoolAddress != address(0),
"0 treasury pool address"
);
treasuryPoolAddress = newTreasuryPoolAddress;
}
function setAdapterAddress(address newAdapterAddress)
external
onlyBy(governanceAccount)
{
require(newAdapterAddress != address(0), "0 adapter address");
adapterAddress = newAdapterAddress;
}
function setLiquidationPenalty(uint256 liquidationPenalty_)
external
onlyBy(governanceAccount)
{
require(liquidationPenalty_ <= 100, "liquidation penalty > 100%");
_farmingPoolConfig.liquidationPenalty = liquidationPenalty_;
}
function pause() external onlyBy(governanceAccount) {
_pause();
}
function unpause() external onlyBy(governanceAccount) {
_unpause();
}
function leverageFactor() external view returns (uint256 leverageFactor_) {
leverageFactor_ = _farmingPoolConfig.leverageFactor;
}
function liquidationPenalty()
external
view
returns (uint256 liquidationPenalty_)
{
liquidationPenalty_ = _farmingPoolConfig.liquidationPenalty;
}
function taxRate() external view returns (uint256 taxRate_) {
taxRate_ = _farmingPoolConfig.taxRate;
}
function borrowerInterestRateModel()
external
view
returns (BorrowerInterestRateModel memory borrowerInterestRateModel_)
{
borrowerInterestRateModel_ = _borrowerInterestRateModel;
}
function getTotalTransferToAdapterFor(address account)
external
view
override
returns (uint256 totalTransferToAdapter)
{
require(account != address(0), "zero account");
totalTransferToAdapter = _totalTransferToAdapter[account];
}
function getLoansAtLastAccrualFor(address account)
external
view
override
returns (
uint256[] memory interestRates,
uint256[] memory principalsOnly,
uint256[] memory principalsWithInterest,
uint256[] memory lastAccrualTimestamps
)
{
require(account != address(0), "zero account");
uint256 numEntries = _farmerLoans[account].length();
interestRates = new uint256[](numEntries);
principalsOnly = new uint256[](numEntries);
principalsWithInterest = new uint256[](numEntries);
lastAccrualTimestamps = new uint256[](numEntries);
for (uint256 i = 0; i < numEntries; i++) {
(uint256 interestRate, IterableLoanMap.Loan memory farmerLoan) =
_farmerLoans[account].at(i);
interestRates[i] = interestRate;
principalsOnly[i] = farmerLoan._principalOnly;
principalsWithInterest[i] = farmerLoan._principalWithInterest;
lastAccrualTimestamps[i] = farmerLoan._lastAccrualTimestamp;
}
}
function getPoolLoansAtLastAccrual()
external
view
override
returns (
uint256[] memory interestRates,
uint256[] memory principalsOnly,
uint256[] memory principalsWithInterest,
uint256[] memory lastAccrualTimestamps
)
{
uint256 numEntries = _poolLoans.length();
interestRates = new uint256[](numEntries);
principalsOnly = new uint256[](numEntries);
principalsWithInterest = new uint256[](numEntries);
lastAccrualTimestamps = new uint256[](numEntries);
for (uint256 i = 0; i < numEntries; i++) {
(uint256 interestRate, IterableLoanMap.Loan memory poolLoan) =
_poolLoans.at(i);
interestRates[i] = interestRate;
principalsOnly[i] = poolLoan._principalOnly;
principalsWithInterest[i] = poolLoan._principalWithInterest;
lastAccrualTimestamps[i] = poolLoan._lastAccrualTimestamp;
}
}
function estimateBorrowerInterestEarning()
external
view
override
returns (uint256 borrowerInterestEarning)
{
(
,
uint256[] memory poolIntegerInterestRates,
IterableLoanMap.Loan[] memory poolSortedLoans
) = accrueInterestForLoan(_poolLoans);
require(
poolIntegerInterestRates.length == poolSortedLoans.length,
"pool len diff"
);
borrowerInterestEarning = getInterestEarning(poolSortedLoans);
}
function needToLiquidate(address account, uint256 liquidationThreshold)
external
view
override
returns (
bool isLiquidate,
uint256 accountRedeemableUnderlyingTokens,
uint256 threshold
)
{
require(account != address(0), "zero account");
uint256 accountBtokenBalance =
IBtoken(btokenAddress).balanceOf(account);
require(accountBtokenBalance > 0, "insufficient BToken");
(
uint256 farmerOutstandingInterest,
uint256[] memory farmerIntegerInterestRates,
IterableLoanMap.Loan[] memory farmerSortedLoans
) = accrueInterestForLoan(_farmerLoans[account]);
require(
farmerIntegerInterestRates.length == farmerSortedLoans.length,
"farmer len diff"
);
accountRedeemableUnderlyingTokens = IAdapter(adapterAddress)
.getRedeemableUnderlyingTokensFor(accountBtokenBalance);
RepaymentDetails memory repaymentDetails =
calculateRepaymentDetails(
account,
accountBtokenBalance,
accountRedeemableUnderlyingTokens,
farmerOutstandingInterest
);
isLiquidate = false;
threshold = repaymentDetails
.loanPrincipalToRepay
.add(repaymentDetails.taxAmount)
.add(repaymentDetails.payableInterest)
.mul(liquidationThreshold.add(PERCENT_100))
.div(PERCENT_100);
if (accountRedeemableUnderlyingTokens < threshold) {
isLiquidate = true;
}
}
/**
* @dev Returns the borrow nominal annual rate round down to nearest integer
*
* @param utilisationRate as percentage in unsigned 64.64-bit fixed point number
* @return integerInterestRate as percentage round down to nearest integer
*/
function getBorrowNominalAnnualRate(uint256 utilisationRate)
public
view
returns (uint256 integerInterestRate)
{
// https://github.com/crytic/slither/wiki/Detector-Documentation#too-many-digits
// slither-disable-next-line too-many-digits
require(utilisationRate <= 0x640000000000000000, "> 100%");
if (
utilisationRate <= _borrowerInterestRateModel.utilisationRatePoint1
) {
integerInterestRate = _borrowerInterestRateModel
.interestRateIntegerPoint1;
} else if (
utilisationRate < _borrowerInterestRateModel.utilisationRatePoint2
) {
uint256 pointSlope =
utilisationRate
.sub(_borrowerInterestRateModel.utilisationRatePoint1)
.mul(_borrowerInterestRateModel.interestRateSlope1) >>
(NUM_FRACTION_BITS * 2);
integerInterestRate = pointSlope.add(
_borrowerInterestRateModel.interestRateIntegerPoint1
);
} else {
uint256 pointSlope =
utilisationRate
.sub(_borrowerInterestRateModel.utilisationRatePoint2)
.mul(_borrowerInterestRateModel.interestRateSlope2) >>
(NUM_FRACTION_BITS * 2);
integerInterestRate = pointSlope.add(
_borrowerInterestRateModel.interestRateIntegerPoint2
);
}
}
/**
* @dev Returns the accrue per second compound interest, reverts if overflow
*
* @param presentValue in wei
* @param nominalAnnualRate as percentage in unsigned integer
* @param numSeconds in unsigned integer
* @return futureValue in wei
*/
function accruePerSecondCompoundInterest(
uint256 presentValue,
uint256 nominalAnnualRate,
uint256 numSeconds
) public pure returns (uint256 futureValue) {
require(nominalAnnualRate <= 100, "> 100%");
uint256 exponent =
numSeconds.mul(
(
((
nominalAnnualRate.add(SECONDS_IN_YEAR.mul(PERCENT_100))
) << NUM_FRACTION_BITS)
.div(SECONDS_IN_YEAR.mul(PERCENT_100))
)
.logBase2()
);
futureValue =
exponent.expBase2().mul(presentValue) >>
NUM_FRACTION_BITS;
}
/**
* @dev Returns the seconds since last accrual
*
* @param currentTimestamp in seconds
* @param lastAccrualTimestamp in seconds
* @return secondsSinceLastAccrual
* @return accrualTimestamp in seconds
*/
function getSecondsSinceLastAccrual(
uint256 currentTimestamp,
uint256 lastAccrualTimestamp
)
public
pure
returns (uint256 secondsSinceLastAccrual, uint256 accrualTimestamp)
{
require(
currentTimestamp >= lastAccrualTimestamp,
"current before last"
);
secondsSinceLastAccrual = currentTimestamp.sub(lastAccrualTimestamp);
accrualTimestamp = currentTimestamp;
}
/**
* @dev Returns the borrower interest rate model parameters
*
* @param integerInterestRatePoint1 point 1 integer interest rate as percentage in unsigned integer
* @param integerInterestRatePoint2 point 2 integer interest rate as percentage in unsigned integer
* @param integerUtilisationRatePoint1 point 1 integer utilisation rate as percentage in unsigned integer
* @param integerUtilisationRatePoint2 point 2 integer utilisation rate as percentage in unsigned integer
* @return utilisationRatePoint1_ point 1 utilisation rate in unsigned 64.64 fixed-point number
* @return utilisationRatePoint2_ point 2 utilisation rate in unsigned 64.64 fixed-point number
* @return interestRateSlope1_ interest rate slope 1 in unsigned 64.64 fixed-point number
* @return interestRateSlope2_ interest rate slope 2 in unsigned 64.64 fixed-point number
*/
function calculateBorrowerInterestRateModel(
uint256 integerInterestRatePoint1,
uint256 integerInterestRatePoint2,
uint256 integerUtilisationRatePoint1,
uint256 integerUtilisationRatePoint2
)
public
pure
returns (
uint256 utilisationRatePoint1_,
uint256 utilisationRatePoint2_,
uint256 interestRateSlope1_,
uint256 interestRateSlope2_
)
{
require(integerInterestRatePoint1 > 0, "0 point 1 interest rate");
require(
integerInterestRatePoint1 < 100,
"point 1 interest rate equal or exceed 100%"
);
require(integerInterestRatePoint2 > 0, "0 point 2 interest rate");
require(
integerInterestRatePoint2 < 100,
"point 2 interest rate equal or exceed 100%"
);
require(integerUtilisationRatePoint1 > 0, "0 point 1 utilisation rate");
require(
integerUtilisationRatePoint1 < 100,
"point 1 utilisation rate equal or exceed 100%"
);
require(integerUtilisationRatePoint2 > 0, "0 point 2 utilisation rate");
require(
integerUtilisationRatePoint2 < 100,
"point 2 utilisation rate equal or exceed 100%"
);
utilisationRatePoint1_ =
integerUtilisationRatePoint1 <<
NUM_FRACTION_BITS;
utilisationRatePoint2_ =
integerUtilisationRatePoint2 <<
NUM_FRACTION_BITS;
interestRateSlope1_ = (integerInterestRatePoint2.sub(
integerInterestRatePoint1
) << (2 * NUM_FRACTION_BITS))
.div(utilisationRatePoint2_.sub(utilisationRatePoint1_));
interestRateSlope2_ = (PERCENT_100.sub(integerInterestRatePoint2) <<
(2 * NUM_FRACTION_BITS))
.div((PERCENT_100 << 64).sub(utilisationRatePoint2_));
}
function accrueInterestForLoan(
IterableLoanMap.RateToLoanMap storage rateToLoanMap
)
private
view
returns (
uint256 outstandingInterest,
uint256[] memory integerInterestRates,
IterableLoanMap.Loan[] memory sortedLoans
)
{
bool[] memory interestRateExists = new bool[](PERCENT_100 + 1);
IterableLoanMap.Loan[] memory loansByInterestRate =
new IterableLoanMap.Loan[](PERCENT_100 + 1);
uint256 numEntries = rateToLoanMap.length();
integerInterestRates = new uint256[](numEntries);
sortedLoans = new IterableLoanMap.Loan[](numEntries);
outstandingInterest = 0;
for (uint256 i = 0; i < numEntries; i++) {
(
uint256 integerNominalAnnualRate,
IterableLoanMap.Loan memory loan
) = rateToLoanMap.at(i);
(uint256 secondsSinceLastAccrual, uint256 accrualTimestamp) =
getSecondsSinceLastAccrual(
block.timestamp,
loan._lastAccrualTimestamp
);
loan._lastAccrualTimestamp = accrualTimestamp;
if (
loan._principalWithInterest > 0 && secondsSinceLastAccrual > 0
) {
loan._principalWithInterest = accruePerSecondCompoundInterest(
loan._principalWithInterest,
integerNominalAnnualRate,
secondsSinceLastAccrual
);
}
outstandingInterest = outstandingInterest
.add(loan._principalWithInterest)
.sub(loan._principalOnly);
loansByInterestRate[integerNominalAnnualRate] = loan;
interestRateExists[integerNominalAnnualRate] = true;
}
uint256 index = 0;
for (
uint256 rate = _borrowerInterestRateModel.interestRateIntegerPoint1;
rate <= PERCENT_100;
rate++
) {
if (interestRateExists[rate]) {
integerInterestRates[index] = rate;
sortedLoans[index] = loansByInterestRate[rate];
index++;
}
}
}
function accrueInterestBasedOnInterestRates(
IterableLoanMap.RateToLoanMap storage rateToLoanMap,
uint256[] memory inIntegerInterestRates
)
private
view
returns (
uint256[] memory outIntegerInterestRates,
IterableLoanMap.Loan[] memory outSortedLoans
)
{
uint256 numEntries = inIntegerInterestRates.length;
outIntegerInterestRates = new uint256[](numEntries);
outSortedLoans = new IterableLoanMap.Loan[](numEntries);
for (uint256 i = 0; i < numEntries; i++) {
(bool keyExists, IterableLoanMap.Loan memory loan) =
rateToLoanMap.tryGet(inIntegerInterestRates[i]);
(uint256 secondsSinceLastAccrual, uint256 accrualTimestamp) =
getSecondsSinceLastAccrual(
block.timestamp,
keyExists ? loan._lastAccrualTimestamp : block.timestamp
);
loan._lastAccrualTimestamp = accrualTimestamp;
if (
loan._principalWithInterest > 0 && secondsSinceLastAccrual > 0
) {
loan._principalWithInterest = accruePerSecondCompoundInterest(
loan._principalWithInterest,
inIntegerInterestRates[i],
secondsSinceLastAccrual
);
}
outIntegerInterestRates[i] = inIntegerInterestRates[i];
outSortedLoans[i] = loan;
}
}
function calculateRepaymentDetails(
address farmerAccount,
uint256 btokenAmount,
uint256 underlyingAssetQuantity,
uint256 outstandingInterest
) public view returns (RepaymentDetails memory repaymentDetails) {
uint256 totalTransferToAdapter = _totalTransferToAdapter[farmerAccount];
// https://github.com/crytic/slither/wiki/Detector-Documentation#divide-before-multiply
// slither-disable-next-line divide-before-multiply
uint256 underlyingAssetInvested =
btokenAmount.mul(totalTransferToAdapter).div(
IBtoken(btokenAddress).balanceOf(farmerAccount)
);
repaymentDetails.underlyingAssetInvested = underlyingAssetInvested;
repaymentDetails.profit = 0;
repaymentDetails.taxAmount = 0;
if (underlyingAssetQuantity > underlyingAssetInvested) {
repaymentDetails.profit = underlyingAssetQuantity.sub(
underlyingAssetInvested
);
repaymentDetails.taxAmount = repaymentDetails
.profit
.mul(_farmingPoolConfig.taxRate)
.div(PERCENT_100);
}
uint256 depositPrincipal =
underlyingAssetInvested.div(_farmingPoolConfig.leverageFactor);
repaymentDetails.depositPrincipal = depositPrincipal;
// slither-disable-next-line divide-before-multiply
repaymentDetails.payableInterest = outstandingInterest
.mul(underlyingAssetInvested)
.div(totalTransferToAdapter);
repaymentDetails.loanPrincipalToRepay = underlyingAssetInvested.sub(
depositPrincipal
);
repaymentDetails.amountToReceive = underlyingAssetQuantity
.sub(repaymentDetails.loanPrincipalToRepay)
.sub(repaymentDetails.taxAmount)
.sub(repaymentDetails.payableInterest);
}
function removeLiquidityFor(address account, uint256 requestedAmount)
private
returns (
RepaymentDetails memory repaymentDetails,
uint256 actualAmount,
uint256 receiveQuantity,
uint256 actualAmountToReceive,
uint256 outstandingInterest
)
{
require(account != address(0), "0 account");
require(requestedAmount > 0, "0 requested amount");
uint256 farmerTotalTransferToAdapter = _totalTransferToAdapter[account];
require(farmerTotalTransferToAdapter > 0, "no transfer");
require(
IBtoken(btokenAddress).balanceOf(account) >= requestedAmount,
"insufficient BToken"
);
(
uint256 farmerOutstandingInterest,
uint256[] memory farmerIntegerInterestRates,
IterableLoanMap.Loan[] memory farmerSortedLoans
) = accrueInterestForLoan(_farmerLoans[account]);
outstandingInterest = farmerOutstandingInterest;
require(
farmerIntegerInterestRates.length == farmerSortedLoans.length,
"farmer len diff"
);
(
uint256[] memory poolIntegerInterestRates,
IterableLoanMap.Loan[] memory poolSortedLoans
) =
accrueInterestBasedOnInterestRates(
_poolLoans,
farmerIntegerInterestRates
);
require(
poolIntegerInterestRates.length == poolSortedLoans.length,
"pool len diff"
);
require(
farmerIntegerInterestRates.length ==
poolIntegerInterestRates.length,
"farmer/pool len diff"
);
// https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-1
// https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2
// https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3
// slither-disable-next-line reentrancy-no-eth,reentrancy-benign,reentrancy-events
(actualAmount, receiveQuantity) = IAdapter(adapterAddress)
.redeemWrappedToken(requestedAmount);
require(
actualAmount <= requestedAmount,
"actual greater than requested amount"
);
repaymentDetails = calculateRepaymentDetails(
account,
actualAmount,
receiveQuantity,
farmerOutstandingInterest
);
_totalTransferToAdapter[account] = farmerTotalTransferToAdapter.sub(
repaymentDetails.underlyingAssetInvested
);
totalInterestEarned = totalInterestEarned.add(
repaymentDetails.payableInterest
);
updateLoansForFarmerAndPoolWithdraw(
account,
farmerIntegerInterestRates,
farmerSortedLoans,
poolSortedLoans,
repaymentDetails
);
{
// scope to avoid stack too deep errors
uint256 underlyingAssetAmount = totalUnderlyingAsset;
if (
underlyingAssetAmount < repaymentDetails.depositPrincipal &&
repaymentDetails.depositPrincipal.sub(underlyingAssetAmount) <
ROUNDING_TOLERANCE
) {
totalUnderlyingAsset = 0;
} else {
totalUnderlyingAsset = underlyingAssetAmount.sub(
repaymentDetails.depositPrincipal
);
}
}
actualAmountToReceive = repaymentDetails.amountToReceive;
{
// scope to avoid stack too deep errors
uint256 farmingPoolUnderlyingAssetBalance =
IERC20(underlyingAssetAddress).balanceOf(address(this));
if (
farmingPoolUnderlyingAssetBalance < actualAmountToReceive &&
actualAmountToReceive.sub(farmingPoolUnderlyingAssetBalance) <
ROUNDING_TOLERANCE
) {
actualAmountToReceive = farmingPoolUnderlyingAssetBalance;
}
}
}
function getInterestEarning(IterableLoanMap.Loan[] memory poolSortedLoans)
private
pure
returns (uint256 interestEarning)
{
interestEarning = 0;
for (uint256 index = 0; index < poolSortedLoans.length; index++) {
interestEarning = interestEarning
.add(poolSortedLoans[index]._principalWithInterest)
.sub(poolSortedLoans[index]._principalOnly);
}
}
function updateLoansForDeposit(
IterableLoanMap.RateToLoanMap storage loans,
uint256 integerNominalAnnualRate,
uint256 loanAmount
) private {
(bool keyExists, IterableLoanMap.Loan memory loan) =
loans.tryGet(integerNominalAnnualRate);
uint256 secondsSinceLastAccrual = 0;
uint256 accrualTimestamp = block.timestamp;
if (keyExists) {
(
secondsSinceLastAccrual,
accrualTimestamp
) = getSecondsSinceLastAccrual(
block.timestamp,
loan._lastAccrualTimestamp
);
}
uint256 presentValue = loan._principalWithInterest;
uint256 futureValue = presentValue;
if (presentValue > 0 && secondsSinceLastAccrual > 0) {
futureValue = accruePerSecondCompoundInterest(
presentValue,
integerNominalAnnualRate,
secondsSinceLastAccrual
);
}
loan._principalOnly = loan._principalOnly.add(loanAmount);
loan._principalWithInterest = futureValue.add(loanAmount);
loan._lastAccrualTimestamp = accrualTimestamp;
// https://github.com/crytic/slither/wiki/Detector-Documentation#unused-return
// slither-disable-next-line unused-return
loans.set(integerNominalAnnualRate, loan);
}
function updateLoansForFarmerAndPoolWithdraw(
address farmerAccount,
uint256[] memory integerInterestRates,
IterableLoanMap.Loan[] memory farmerSortedLoans,
IterableLoanMap.Loan[] memory poolSortedLoans,
RepaymentDetails memory repaymentDetails
) private {
require(integerInterestRates.length > 0, "integerInterestRates len");
require(
farmerSortedLoans.length == integerInterestRates.length,
"farmerSortedLoans len"
);
require(
poolSortedLoans.length == integerInterestRates.length,
"poolSortedLoans len"
);
uint256 repayPrincipalRemaining = repaymentDetails.loanPrincipalToRepay;
uint256 repayPrincipalWithInterestRemaining =
repaymentDetails.loanPrincipalToRepay.add(
repaymentDetails.payableInterest
);
for (uint256 index = integerInterestRates.length; index > 0; index--) {
if (repayPrincipalRemaining > 0) {
if (
farmerSortedLoans[index - 1]._principalOnly >=
repayPrincipalRemaining
) {
farmerSortedLoans[index - 1]
._principalOnly = farmerSortedLoans[index - 1]
._principalOnly
.sub(repayPrincipalRemaining);
poolSortedLoans[index - 1]._principalOnly = poolSortedLoans[
index - 1
]
._principalOnly
.sub(repayPrincipalRemaining);
repayPrincipalRemaining = 0;
} else {
poolSortedLoans[index - 1]._principalOnly = poolSortedLoans[
index - 1
]
._principalOnly
.sub(farmerSortedLoans[index - 1]._principalOnly);
repayPrincipalRemaining = repayPrincipalRemaining.sub(
farmerSortedLoans[index - 1]._principalOnly
);
farmerSortedLoans[index - 1]._principalOnly = 0;
}
}
if (repayPrincipalWithInterestRemaining > 0) {
if (
farmerSortedLoans[index - 1]._principalWithInterest >=
repayPrincipalWithInterestRemaining
) {
farmerSortedLoans[index - 1]
._principalWithInterest = farmerSortedLoans[index - 1]
._principalWithInterest
.sub(repayPrincipalWithInterestRemaining);
if (
poolSortedLoans[index - 1]._principalWithInterest <
repayPrincipalWithInterestRemaining &&
repayPrincipalWithInterestRemaining.sub(
poolSortedLoans[index - 1]._principalWithInterest
) <
ROUNDING_TOLERANCE
) {
poolSortedLoans[index - 1]._principalWithInterest = 0;
} else {
poolSortedLoans[index - 1]
._principalWithInterest = poolSortedLoans[index - 1]
._principalWithInterest
.sub(repayPrincipalWithInterestRemaining);
}
repayPrincipalWithInterestRemaining = 0;
} else {
if (
poolSortedLoans[index - 1]._principalWithInterest <
farmerSortedLoans[index - 1]._principalWithInterest &&
farmerSortedLoans[index - 1]._principalWithInterest.sub(
poolSortedLoans[index - 1]._principalWithInterest
) <
ROUNDING_TOLERANCE
) {
poolSortedLoans[index - 1]._principalWithInterest = 0;
} else {
poolSortedLoans[index - 1]
._principalWithInterest = poolSortedLoans[index - 1]
._principalWithInterest
.sub(
farmerSortedLoans[index - 1]._principalWithInterest
);
}
repayPrincipalWithInterestRemaining = repayPrincipalWithInterestRemaining
.sub(
farmerSortedLoans[index - 1]._principalWithInterest
);
farmerSortedLoans[index - 1]._principalWithInterest = 0;
}
}
if (
farmerSortedLoans[index - 1]._principalOnly > 0 ||
farmerSortedLoans[index - 1]._principalWithInterest > 0
) {
// https://github.com/crytic/slither/wiki/Detector-Documentation#unused-return
// slither-disable-next-line unused-return
_farmerLoans[farmerAccount].set(
integerInterestRates[index - 1],
farmerSortedLoans[index - 1]
);
} else {
// slither-disable-next-line unused-return
_farmerLoans[farmerAccount].remove(
integerInterestRates[index - 1]
);
}
if (
poolSortedLoans[index - 1]._principalOnly > 0 ||
poolSortedLoans[index - 1]._principalWithInterest > 0
) {
// slither-disable-next-line unused-return
_poolLoans.set(
integerInterestRates[index - 1],
poolSortedLoans[index - 1]
);
} else {
// slither-disable-next-line unused-return
_poolLoans.remove(integerInterestRates[index - 1]);
}
}
}
function updateLoansForPoolComputeInterest(
uint256[] memory integerInterestRates,
IterableLoanMap.Loan[] memory poolSortedLoans
) private {
require(
poolSortedLoans.length == integerInterestRates.length,
"poolSortedLoans len"
);
for (uint256 index = 0; index < integerInterestRates.length; index++) {
if (
poolSortedLoans[index]._principalOnly > 0 ||
poolSortedLoans[index]._principalWithInterest > 0
) {
// slither-disable-next-line unused-return
_poolLoans.set(
integerInterestRates[index],
poolSortedLoans[index]
);
} else {
// slither-disable-next-line unused-return
_poolLoans.remove(integerInterestRates[index]);
}
}
}
}
| as percentage in unsigned integer
| uint256 interestRateIntegerPoint2; | 13,107,336 | [
1,
345,
11622,
316,
9088,
3571,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
3639,
2254,
5034,
16513,
4727,
4522,
2148,
22,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0xDf24D7F73Bec8D0B34915Ecd8a00AE3598A1fA2c/sources/contracts/EtchMarket.sol | Check the maker ask order Execute the transaction Refund dust token to sender | function executeEthscriptionOrder(
OrderTypes.EthscriptionOrder calldata order,
bytes calldata trustedSign
) public payable override nonReentrant whenNotPaused {
bytes32 orderHash = _verifyOrderHash(order, trustedSign);
_executeOrder(order, orderHash);
_returnDust();
}
| 3,171,069 | [
1,
1564,
326,
312,
6388,
6827,
1353,
7903,
326,
2492,
3941,
1074,
302,
641,
1147,
358,
5793,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
1836,
41,
451,
3100,
2448,
12,
203,
3639,
4347,
2016,
18,
41,
451,
3100,
2448,
745,
892,
1353,
16,
203,
3639,
1731,
745,
892,
13179,
2766,
203,
565,
262,
1071,
8843,
429,
3849,
1661,
426,
8230,
970,
1347,
1248,
28590,
288,
203,
3639,
1731,
1578,
1353,
2310,
273,
389,
8705,
2448,
2310,
12,
1019,
16,
13179,
2766,
1769,
203,
203,
3639,
389,
8837,
2448,
12,
1019,
16,
1353,
2310,
1769,
203,
203,
3639,
389,
2463,
40,
641,
5621,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/4/0x8619ce3bd7827AA4bD0E9787EE27e74FBb3A2Dfa/sources/SmolStudio.sol | * @title SafeMath @dev Unsigned math operations with safety checks that revert on error/ | library SafeMath {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "safemath#mul: OVERFLOW");
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "safemath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "safemath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "safemath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "safemath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "safemath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
| 8,581,174 | [
1,
9890,
10477,
225,
1351,
5679,
4233,
5295,
598,
24179,
4271,
716,
15226,
603,
555,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
12083,
14060,
10477,
288,
203,
203,
97,
203,
565,
445,
14064,
12,
11890,
5034,
279,
16,
2254,
5034,
324,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
309,
261,
69,
422,
374,
13,
288,
203,
5411,
327,
374,
31,
203,
3639,
289,
203,
203,
3639,
2254,
5034,
276,
273,
279,
380,
324,
31,
203,
3639,
2583,
12,
71,
342,
279,
422,
324,
16,
315,
87,
1727,
351,
421,
7,
16411,
30,
22577,
17430,
8863,
203,
203,
3639,
327,
276,
31,
203,
565,
289,
203,
203,
565,
445,
14064,
12,
11890,
5034,
279,
16,
2254,
5034,
324,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
309,
261,
69,
422,
374,
13,
288,
203,
5411,
327,
374,
31,
203,
3639,
289,
203,
203,
3639,
2254,
5034,
276,
273,
279,
380,
324,
31,
203,
3639,
2583,
12,
71,
342,
279,
422,
324,
16,
315,
87,
1727,
351,
421,
7,
16411,
30,
22577,
17430,
8863,
203,
203,
3639,
327,
276,
31,
203,
565,
289,
203,
203,
565,
445,
3739,
12,
11890,
5034,
279,
16,
2254,
5034,
324,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
2583,
12,
70,
405,
374,
16,
315,
87,
1727,
351,
421,
7,
2892,
30,
3690,
25216,
67,
6486,
67,
24968,
8863,
203,
3639,
2254,
5034,
276,
273,
279,
342,
324,
31,
203,
203,
3639,
327,
276,
31,
203,
565,
289,
203,
203,
565,
445,
720,
12,
11890,
5034,
279,
16,
2254,
5034,
324,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
2
]
|
pragma solidity ^0.4.18; // solhint-disable-line
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
// Required methods
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 tokenId);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
contract StarzToken is ERC721 {
/*** EVENTS ***/
/// @dev The Birth event is fired whenever a new person comes into existence.
event Birth(uint256 tokenId, string name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
/*** CONSTANTS ***/
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "CryptoStarz"; // solhint-disable-line
string public constant SYMBOL = "StarzToken"; // solhint-disable-line
uint256 private startingPrice = 0.01 ether;
uint256 private constant PROMO_CREATION_LIMIT = 5000;
uint256 private firstStepLimit = 0.99999 ether;
uint256 private secondStepLimit = 1.0 ether;
/*** STORAGE ***/
/// @dev A mapping from person IDs to the address that owns them. All persons have
/// some valid owner address.
mapping (uint256 => address) public personIndexToOwner;
// @dev A mapping from owner address to count of tokens that address owns.
// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from PersonIDs to an address that has been approved to call
/// transferFrom(). Each Person can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public personIndexToApproved;
// @dev A mapping from PersonIDs to the price of the token.
mapping (uint256 => uint256) private personIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
uint256 public promoCreatedCount;
/*** DATATYPES ***/
struct Person {
string name;
}
Person[] private persons;
/*** ACCESS MODIFIERS ***/
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(
msg.sender == ceoAddress ||
msg.sender == cooAddress
);
_;
}
/*** CONSTRUCTOR ***/
function StarzToken() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/*** PUBLIC FUNCTIONS ***/
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(
address _to,
uint256 _tokenId
) public {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
personIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
/// @dev Creates a new promo Person with the given name, with given _price and assignes it to an address.
function createPromoPerson(address _owner, string _name, uint256 _price) public onlyCOO {
require(promoCreatedCount < PROMO_CREATION_LIMIT);
address personOwner = _owner;
if (personOwner == address(0)) {
personOwner = cooAddress;
}
if (_price <= 0) {
_price = startingPrice;
}
promoCreatedCount++;
_createPerson(_name, personOwner, _price);
}
/// @dev Creates a new Person with the given name.
function createContractPerson(string _name) public onlyCOO {
_createPerson(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific person.
/// @param _tokenId The tokenId of the person of interest.
function getPerson(uint256 _tokenId) public view returns (
string personName,
uint256 sellingPrice,
address owner
) {
Person storage person = persons[_tokenId];
personName = person.name;
sellingPrice = personIndexToPrice[_tokenId];
owner = personIndexToOwner[_tokenId];
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = personIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
// Allows someone to send ether and obtain the token
function purchase(uint256 _tokenId) public payable {
address oldOwner = personIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = personIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 88), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
// Update prices
if (sellingPrice < firstStepLimit) {
// first stage
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 88);
} else if (sellingPrice < secondStepLimit) {
// second stage
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 118), 88);
} else {
// third stage
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 118), 88);
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.06)
}
TokenSold(_tokenId, sellingPrice, personIndexToPrice[_tokenId], oldOwner, newOwner, persons[_tokenId].name);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return personIndexToPrice[_tokenId];
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = personIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
/// @param _owner The owner whose celebrity tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire Persons array looking for persons belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalPersons = totalSupply();
uint256 resultIndex = 0;
uint256 personId;
for (personId = 0; personId <= totalPersons; personId++) {
if (personIndexToOwner[personId] == _owner) {
result[resultIndex] = personId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return persons.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(
address _to,
uint256 _tokenId
) public {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/*** PRIVATE FUNCTIONS ***/
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return personIndexToApproved[_tokenId] == _to;
}
/// For creating Person
function _createPerson(string _name, address _owner, uint256 _price) private {
Person memory _person = Person({
name: _name
});
uint256 newPersonId = persons.push(_person) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newPersonId == uint256(uint32(newPersonId)));
Birth(newPersonId, _name, _owner);
personIndexToPrice[newPersonId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newPersonId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == personIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// @dev Assigns ownership of a specific Person to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of persons is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
personIndexToOwner[_tokenId] = _to;
// When creating new persons _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete personIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | solhint-disable-line
| string public constant NAME = "CryptoStarz"; | 10,658,439 | [
1,
18281,
11317,
17,
8394,
17,
1369,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
533,
1071,
5381,
6048,
273,
315,
18048,
18379,
94,
14432,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0x9662833c1FC8f2AfF8569816208E8f7653eC8af4/sources/YouAreTheChampion.sol | * @dev Return the log in base 10, rounded down, of a positive value. Returns 0 if given 0./ | function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
| 2,889,348 | [
1,
990,
326,
613,
316,
1026,
1728,
16,
16729,
2588,
16,
434,
279,
6895,
460,
18,
2860,
374,
309,
864,
374,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
613,
2163,
12,
11890,
5034,
460,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
2254,
5034,
563,
273,
374,
31,
203,
565,
22893,
288,
203,
3639,
309,
261,
1132,
1545,
1728,
636,
1105,
13,
288,
203,
5411,
460,
9531,
1728,
636,
1105,
31,
203,
5411,
563,
1011,
5178,
31,
203,
3639,
289,
203,
3639,
309,
261,
1132,
1545,
1728,
636,
1578,
13,
288,
203,
5411,
460,
9531,
1728,
636,
1578,
31,
203,
5411,
563,
1011,
3847,
31,
203,
3639,
289,
203,
3639,
309,
261,
1132,
1545,
1728,
636,
2313,
13,
288,
203,
5411,
460,
9531,
1728,
636,
2313,
31,
203,
5411,
563,
1011,
2872,
31,
203,
3639,
289,
203,
3639,
309,
261,
1132,
1545,
1728,
636,
28,
13,
288,
203,
5411,
460,
9531,
1728,
636,
28,
31,
203,
5411,
563,
1011,
1725,
31,
203,
3639,
289,
203,
3639,
309,
261,
1132,
1545,
1728,
636,
24,
13,
288,
203,
5411,
460,
9531,
1728,
636,
24,
31,
203,
5411,
563,
1011,
1059,
31,
203,
3639,
289,
203,
3639,
309,
261,
1132,
1545,
1728,
636,
22,
13,
288,
203,
5411,
460,
9531,
1728,
636,
22,
31,
203,
5411,
563,
1011,
576,
31,
203,
3639,
289,
203,
3639,
309,
261,
1132,
1545,
1728,
636,
21,
13,
288,
203,
5411,
563,
1011,
404,
31,
203,
3639,
289,
203,
565,
289,
203,
3639,
327,
563,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/4/0x310060e9EC03EaBedfbb3807c815a9a601a49f22/sources/contracts/JBController.sol | / This controller must not be the project's current controller. | function prepForMigrationOf(uint256 _projectId, IJBController) external override {
if (directory.controllerOf(_projectId) == this) {
revert CANT_MIGRATE_TO_CURRENT_CONTROLLER();
}
}
Allows a project to migrate from this controller to another.
@dev
Only a project's owner or a designated operator can migrate it.
@param _projectId The ID of the project that will be migrated from this controller.
@param _to The controller to which the project is migrating.
| 12,272,687 | [
1,
19,
1220,
2596,
1297,
486,
506,
326,
1984,
1807,
783,
2596,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
445,
13237,
1290,
10224,
951,
12,
11890,
5034,
389,
4406,
548,
16,
467,
8877,
2933,
13,
3903,
3849,
288,
203,
565,
309,
261,
5149,
18,
5723,
951,
24899,
4406,
548,
13,
422,
333,
13,
288,
203,
1377,
15226,
385,
6856,
67,
49,
3047,
24062,
67,
4296,
67,
15487,
67,
6067,
25353,
5621,
203,
565,
289,
203,
203,
225,
289,
203,
203,
565,
25619,
279,
1984,
358,
13187,
628,
333,
2596,
358,
4042,
18,
203,
203,
565,
632,
5206,
203,
565,
5098,
279,
1984,
1807,
3410,
578,
279,
25264,
3726,
848,
13187,
518,
18,
203,
203,
565,
632,
891,
389,
4406,
548,
1021,
1599,
434,
326,
1984,
716,
903,
506,
24741,
628,
333,
2596,
18,
203,
565,
632,
891,
389,
869,
1021,
2596,
358,
1492,
326,
1984,
353,
4196,
1776,
18,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0xDEb0f00071497a5cc9b4A6B96068277e57A82Ae2/sources/contracts/beanstalk/AppStorage.sol | * @notice Defines the state object for a Farmer. @param field A Farmer's Field storage. @param bean A Farmer's Unripe Bean Deposits only as a result of Replant (previously held the V1 Silo Deposits/Withdrawals for Beans). @param lp A Farmer's Unripe LP Deposits as a result of Replant of BEAN:ETH Uniswap v2 LP Tokens (previously held the V1 Silo Deposits/Withdrawals for BEAN:ETH Uniswap v2 LP Tokens). @param s A Farmer's Silo storage. @param deprecated_votedUntil DEPRECATED – Replant removed on-chain governance including the ability to vote on BIPs. @param lastUpdate The Season in which the Farmer last updated their Silo. @param lastSop The last Season that a SOP occured at the time the Farmer last updated their Silo. @param lastRain The last Season that it started Raining at the time the Farmer last updated their Silo. @param deprecated_lastSIs DEPRECATED – In Silo V1.2, the Silo reward mechanism was updated to no longer need to store the number of the Supply Increases at the time the Farmer last updated their Silo. @param deprecated_proposedUntil DEPRECATED – Replant removed on-chain governance including the ability to propose BIPs. @param deprecated_sop DEPRECATED – Replant reset the Season of Plenty mechanism @param roots A Farmer's Root balance. @param deprecated_wrappedBeans DEPRECATED – Replant generalized Internal Balances. Wrapped Beans are now stored at the AppStorage level. @param deposits A Farmer's Silo Deposits stored as a map from Token address to Season of Deposit to Deposit. @param withdrawals A Farmer's Withdrawals from the Silo stored as a map from Token address to Season the Withdrawal becomes Claimable to Withdrawn amount of Tokens. @param sop A Farmer's Season of Plenty storage. @param depositAllowances A mapping of `spender => Silo token address => amount`. @param tokenAllowances Internal balance token allowances. @param depositPermitNonces A Farmer's current deposit permit nonce @param tokenPermitNonces A Farmer's current token permit nonce/ | struct State {
AssetSilo bean;
AssetSilo lp;
Silo s;
| 17,187,396 | [
1,
15109,
326,
919,
733,
364,
279,
478,
4610,
264,
18,
225,
652,
432,
478,
4610,
264,
1807,
2286,
2502,
18,
225,
3931,
432,
478,
4610,
264,
1807,
1351,
566,
347,
7704,
4019,
538,
1282,
1338,
487,
279,
563,
434,
868,
412,
970,
261,
11515,
715,
15770,
326,
776,
21,
348,
31703,
4019,
538,
1282,
19,
1190,
9446,
1031,
364,
4823,
634,
2934,
225,
12423,
432,
478,
4610,
264,
1807,
1351,
566,
347,
511,
52,
4019,
538,
1282,
487,
279,
563,
434,
868,
412,
970,
434,
9722,
1258,
30,
1584,
44,
1351,
291,
91,
438,
331,
22,
511,
52,
13899,
261,
11515,
715,
15770,
326,
776,
21,
348,
31703,
4019,
538,
1282,
19,
1190,
9446,
1031,
364,
9722,
1258,
30,
1584,
44,
1351,
291,
91,
438,
331,
22,
511,
52,
13899,
2934,
225,
272,
432,
478,
4610,
264,
1807,
348,
31703,
2502,
18,
225,
6849,
67,
90,
16474,
9716,
2
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
]
| [
1,
565,
1958,
3287,
288,
203,
203,
203,
3639,
10494,
19740,
83,
3931,
31,
7010,
203,
3639,
10494,
19740,
83,
12423,
31,
7010,
203,
3639,
348,
31703,
272,
31,
203,
540,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity >=0.4.21 <0.6.0;
// *** Token contract ***
// *** Used to define the ECR20 token ***
contract IOToken {
// *** Name of the token ***
// *** Optional for ERC20 standard ***
// *** State variable ***
// *** accessible using instance.name(); ***
string public name = "Input Output Flexibility Token";
// *** Symbol of the token ***
// *** Optional for ERC20 standard ***
// *** State variable ***
// *** accessible using instance.symbol(); ***
string public symbol = "IOFT";
// *** Internal standard version of the token ***
// *** State variable ***
// *** accessible using instance.standard(); ***
string public standard = "v0.0.0";
// *** Total supply of tokens ***
// *** Required for ERC20 standard ***
// *** State variable ***
// *** accessible using instance.totalSupply(); ***
uint256 public totalSupply;
// *** Balance of addresses ***
// *** Required for ERC20 standard ***
// *** State variable ***
// *** accessible using instance.balanceOf(address);
mapping(address => uint256) public balanceOf;
// *** Delegated Transfer Allowances ***
// *** Required for ERC20 standard ***
// *** State variable ***
mapping(address => mapping(address => uint256)) public allowance;
// *** Approval event handler ***
// *** Required ERC20 standard ***
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value
);
// *** Transfer event handler ***
// *** Required ERC20 standard ***
event Transfer(
address indexed _from,
address indexed _to,
uint256 _value
);
// *** Constructor ***
// *** uint256 _initialSupply - local scope variable ***
constructor (uint256 _initialSupply) public {
// *** Allocate the initial supply ***
// *** msg is a global variable in solidity ***
// *** msg.sender is the address that called the contract ***
balanceOf[msg.sender] = _initialSupply;
// *** Set the total supply of tokens ***
totalSupply = _initialSupply;
}
// *** Approve function ***
// *** Required by ERC20 standard ***
function approve(address _spender, uint256 _value) public returns(bool success){
// *** set the allowance value ***
allowance[msg.sender][_spender] = _value;
// *** trigger approval event ***
emit Approval(msg.sender, _spender, _value);
// *** Return true if the function has executed this far. ***
return true;
}
// *** Transfer function ***
// *** Required by ERC20 standard ***
// *** Exception: if account doesn't have enough supply for xfer ***
// *** Returns: boolean ***
function transfer(address _to, uint256 _value) public returns(bool success){
// *** Ensure the sender has at least the desired amount of tokens to transfer ***
require(balanceOf[msg.sender] >= _value, "balance not available to send.");
// *** Deduct balance (_value) from sender ***
balanceOf[msg.sender] -= _value;
// *** Add balance (_value) to receiver ***
balanceOf[_to] += _value;
// *** Emit the transfer event ***
emit Transfer(msg.sender, _to, _value);
// *** Return true if the function has executed this far. ***
return true;
}
// *** Transfer from function ***
// *** "Delegated" Transfer ***
// *** Required by ERC20 standard ***
// *** Exception: if calling account allowance is not large enough to transfer value. ***
// *** Exception: if spending account balance is not large enought to transfer value. ***
// *** Returns: boolean ***
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
// *** Ensure the delegate's allowance is appropriate to transfer ***
require(_value <= allowance[_from][msg.sender], "allowance is not large enough to transfer");
// *** Ensure the _from account has enough tokens to transfer ***
require(_value <= balanceOf[_from], "balance is not available to transfer");
// *** Deduct balance (_value) from sender ***
balanceOf[_from] -= _value;
// *** Add balance (_value) to receiver ***
balanceOf[_to] += _value;
// *** Update the remaining allowance ***
allowance[_from][msg.sender] -= _value;
// *** Emit the transfer event ***
emit Transfer(_from, _to, _value);
// *** Return true if the function has executed this far. ***
return true;
}
} | *** Transfer function *** *** Required by ERC20 standard *** *** Exception: if account doesn't have enough supply for xfer *** *** Returns: boolean *** *** Ensure the sender has at least the desired amount of tokens to transfer *** *** Deduct balance (_value) from sender *** *** Add balance (_value) to receiver *** *** Emit the transfer event *** *** Return true if the function has executed this far. *** | function transfer(address _to, uint256 _value) public returns(bool success){
require(balanceOf[msg.sender] >= _value, "balance not available to send.");
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
| 1,078,317 | [
1,
5912,
445,
282,
10647,
635,
4232,
39,
3462,
4529,
282,
1185,
30,
309,
2236,
3302,
1404,
1240,
7304,
14467,
364,
619,
586,
282,
2860,
30,
1250,
282,
7693,
326,
5793,
711,
622,
4520,
326,
6049,
3844,
434,
2430,
358,
7412,
282,
463,
329,
853,
11013,
261,
67,
1132,
13,
628,
5793,
282,
1436,
11013,
261,
67,
1132,
13,
358,
5971,
282,
16008,
326,
7412,
871,
282,
2000,
638,
309,
326,
445,
711,
7120,
333,
10247,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
7412,
12,
2867,
389,
869,
16,
2254,
5034,
389,
1132,
13,
1071,
1135,
12,
6430,
2216,
15329,
203,
3639,
2583,
12,
12296,
951,
63,
3576,
18,
15330,
65,
1545,
389,
1132,
16,
315,
12296,
486,
2319,
358,
1366,
1199,
1769,
203,
203,
3639,
11013,
951,
63,
3576,
18,
15330,
65,
3947,
389,
1132,
31,
203,
203,
3639,
11013,
951,
63,
67,
869,
65,
1011,
389,
1132,
31,
203,
203,
3639,
3626,
12279,
12,
3576,
18,
15330,
16,
389,
869,
16,
389,
1132,
1769,
203,
203,
3639,
327,
638,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/80001/0xE387222a2154b5e7285bF23e808D68e0a213b5a1/sources/src/core/ContinuousDaoSetup.sol | adding addresses directly into the helpers array to get around the stack limit Prepare permissions Voting Permissions Token Permissions MatketMaker Permission | function prepareInstallation(
address _dao,
bytes calldata _data
)
external
returns (address plugin, PreparedSetupData memory preparedSetupData)
{
(
string memory name,
string memory symbol,
address externalToken,
MajorityVotingBase.VotingSettings memory votingSettings,
CurveParameters memory curve,
address hatchAdmin
) = abi.decode(_data, (string, string, address, MajorityVotingBase.VotingSettings, CurveParameters, address));
address[] memory helpers = new address[](3);
helpers[0] = governanceERC20Base.clone();
helpers[1] = marketMakerBase.clone();
GovernanceBurnableERC20(helpers[0]).initialize(IDAO(_dao), name, symbol);
MarketMaker(helpers[1]).initialize(
IDAO(_dao), GovernanceBurnableERC20(helpers[0]), IERC20(externalToken), curve
);
plugin = createERC1967Proxy(
address(tokenVotingBase),
abi.encodeWithSelector(TokenVoting.initialize.selector, _dao, votingSettings, helpers[0])
);
emit DeployedContracts(plugin, helpers[0], helpers[1], helpers[2]);
PermissionLib.MultiTargetPermission[] memory permissions = new PermissionLib.MultiTargetPermission[](6);
permissions[0] = PermissionLib.MultiTargetPermission(
PermissionLib.Operation.Grant,
plugin,
_dao,
PermissionLib.NO_CONDITION,
TokenVoting(tokenVotingBase).UPDATE_VOTING_SETTINGS_PERMISSION_ID()
);
permissions[1] = PermissionLib.MultiTargetPermission(
PermissionLib.Operation.Grant,
plugin,
_dao,
PermissionLib.NO_CONDITION,
TokenVoting(tokenVotingBase).UPGRADE_PLUGIN_PERMISSION_ID()
);
permissions[2] = PermissionLib.MultiTargetPermission(
PermissionLib.Operation.Grant,
_dao,
plugin,
PermissionLib.NO_CONDITION,
DAO(payable(_dao)).EXECUTE_PERMISSION_ID()
);
permissions[3] = PermissionLib.MultiTargetPermission(
PermissionLib.Operation.Grant,
PermissionLib.NO_CONDITION,
GovernanceBurnableERC20(helpers[0]).MINTER_ROLE_ID()
);
permissions[4] = PermissionLib.MultiTargetPermission(
PermissionLib.Operation.Grant,
PermissionLib.NO_CONDITION,
MarketMaker(helpers[1]).HATCH_PERMISSION_ID()
);
permissions[5] = PermissionLib.MultiTargetPermission(
PermissionLib.Operation.Grant,
plugin,
PermissionLib.NO_CONDITION,
MarketMaker(helpers[1]).CONFIGURE_PERMISSION_ID()
);
preparedSetupData.helpers = helpers;
preparedSetupData.permissions = permissions;
}
| 8,803,260 | [
1,
3439,
6138,
5122,
1368,
326,
9246,
526,
358,
336,
6740,
326,
2110,
1800,
7730,
4371,
776,
17128,
15684,
3155,
15684,
14493,
79,
278,
12373,
8509,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
2911,
21790,
12,
203,
3639,
1758,
389,
2414,
83,
16,
203,
3639,
1731,
745,
892,
389,
892,
203,
565,
262,
203,
3639,
3903,
203,
3639,
1135,
261,
2867,
1909,
16,
13893,
7365,
751,
3778,
8208,
7365,
751,
13,
203,
565,
288,
203,
3639,
261,
203,
5411,
533,
3778,
508,
16,
203,
5411,
533,
3778,
3273,
16,
203,
5411,
1758,
3903,
1345,
16,
203,
5411,
25977,
560,
58,
17128,
2171,
18,
58,
17128,
2628,
3778,
331,
17128,
2628,
16,
203,
5411,
22901,
2402,
3778,
8882,
16,
203,
5411,
1758,
366,
505,
4446,
203,
3639,
262,
273,
24126,
18,
3922,
24899,
892,
16,
261,
1080,
16,
533,
16,
1758,
16,
25977,
560,
58,
17128,
2171,
18,
58,
17128,
2628,
16,
22901,
2402,
16,
1758,
10019,
203,
203,
3639,
1758,
8526,
3778,
9246,
273,
394,
1758,
8526,
12,
23,
1769,
203,
203,
3639,
9246,
63,
20,
65,
273,
314,
1643,
82,
1359,
654,
39,
3462,
2171,
18,
14056,
5621,
203,
3639,
9246,
63,
21,
65,
273,
13667,
12373,
2171,
18,
14056,
5621,
203,
203,
3639,
611,
1643,
82,
1359,
38,
321,
429,
654,
39,
3462,
12,
11397,
63,
20,
65,
2934,
11160,
12,
734,
20463,
24899,
2414,
83,
3631,
508,
16,
3273,
1769,
203,
3639,
6622,
278,
12373,
12,
11397,
63,
21,
65,
2934,
11160,
12,
203,
5411,
1599,
20463,
24899,
2414,
83,
3631,
611,
1643,
82,
1359,
38,
321,
429,
654,
39,
3462,
12,
11397,
63,
20,
65,
3631,
467,
654,
39,
3462,
12,
9375,
1345,
3631,
8882,
203,
3639,
11272,
203,
203,
3639,
2
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "./TellorStake.sol";
import "./TellorGetters.sol";
import "./Utilities.sol";
import "./ITellor.sol";
import "./SafeMath.sol";
/**
* @title Tellor Oracle System
* @dev Oracle contract where miners can submit the proof of work along with the value.
*/
contract Tellor is TellorStake {
using SafeMath for uint256;
event TipAdded(
address indexed _sender,
uint256 indexed _requestId,
uint256 _tip,
uint256 _totalTips
);
//emits when a new challenge is created (either on mined block or when a new request is pushed forward on waiting system)
event NewChallenge(
bytes32 indexed _currentChallenge,
uint256[5] _currentRequestId,
uint256 _difficulty,
uint256 _totalTips
);
//Emits upon a successful Mine, indicates the blockTime at point of the mine and the value mined
event NewValue(
uint256[5] _requestId,
uint256 _time,
uint256[5] _value,
uint256 _totalTips,
bytes32 indexed _currentChallenge
);
//Emits upon each mine (5 total) and shows the miner, nonce, and value submitted
event NonceSubmitted(
address indexed _miner,
string _nonce,
uint256[5] _requestId,
uint256[5] _value,
bytes32 indexed _currentChallenge,
uint256 _slot
);
/**
* @dev allows for the deity to update the Extension contract address
* @param _ext the address of the new Extension Contract
*/
function changeExtension(address _ext) external {
require(msg.sender == addresses[_DEITY], "only deity can call this fn");
addresses[_EXTENSION] = _ext;
}
/**
* @dev allows for the deity to update the Migrator contract address
* @param _migrator the address of the new Tellor Contract
*/
function changeMigrator(address _migrator) external {
require(msg.sender == addresses[_DEITY], "only deity can call this fn");
addresses[_MIGRATOR] = _migrator;
}
/**
* @dev This is an internal function used by the function migrate that helps to
* swap old trb tokens for new ones based on the user's old Tellor balance
* @param _user is the msg.sender address of the user to migrate the balance from
*/
function _migrate(address _user) internal {
require(!migrated[_user], "Already migrated");
_doMint(_user, ITellor(addresses[_OLD_TELLOR]).balanceOf(_user));
migrated[_user] = true;
}
/**
* @dev This is an external function used by only the Migrator contract that helps to
* swap old trb tokens for new ones based on a custom amount and allows it
* to bypass the flag for an address that has already migrated. This is needed to ensure
* tokens locked on contract(pool) can be transfered to a user and also allow them to
* swap old tokens to the same address if it held any
* @param _origin is the address of the user to migrate the balance from
* @param _destination is the address that will receive tokens
* @param _amount is the amount to mint to the user
* @param _bypass is a flag used by the migrator to allow it to bypass the "migrated = true" flag
*/
function migrateFrom(
address _origin,
address _destination,
uint256 _amount,
bool _bypass
) external {
require(msg.sender == addresses[_MIGRATOR], "not allowed");
_migrateFrom(_origin, _destination, _amount, _bypass);
}
/**
* @dev This is an external function used by only the Migrator contract that helps to
* swap old trb tokens for new ones based on a custom amount
* @param _origin is an array of user addresses to migrate the balance from
* @param _destination is an array of the address that will receive tokens
* @param _amount is the amount to mint to the user
*/
function migrateFromBatch(
address[] calldata _origin,
address[] calldata _destination,
uint256[] calldata _amount
) external {
require(msg.sender == addresses[_MIGRATOR], "not allowed");
require(
_origin.length == _destination.length &&
_origin.length == _amount.length,
"mismatching input"
);
for (uint256 index = 0; index < _origin.length; index++) {
_migrateFrom(
_origin[index],
_destination[index],
_amount[index],
false
);
}
}
/**
* @dev This is an internal function used by the function migrate that helps to
* swap old trb tokens for new ones based on a custom amount and it allows
* the migrator contact to swap contract locked tokens even if the user has previosly migrated.
* @param _origin is the address of the user to migrate the balance from
* @param _destination is the address that will receive tokens
* @param _amount is the amount to mint to the user
* @param _bypass is a flag used by the migrator to allow it to bypass the "migrated = true" flag
*/
function _migrateFrom(
address _origin,
address _destination,
uint256 _amount,
bool _bypass
) internal {
if (!_bypass) require(!migrated[_origin], "already migrated");
_doMint(_destination, _amount);
migrated[_origin] = true;
}
/**
* @dev This is function used by the function migrate that helps to
* swap old trb tokens for new ones based on the user's old Tellor balance
* @param _destination is the address that will receive tokens
* @param _amount is the amount to mint to the user
*/
function migrateFor(
address _destination,
uint256 _amount,
bool _bypass
) external {
require(msg.sender == addresses[_MIGRATOR], "not allowed");
_migrateFor(_destination, _amount, _bypass);
}
/**
* @dev This is an internal function used by the function migrate that helps to
* swap old trb tokens for new ones based on a custom amount
* @param _destination is the address that will receive tokens
* @param _amount is the amount to mint to the user
*/
function migrateForBatch(
address[] calldata _destination,
uint256[] calldata _amount
) external {
require(msg.sender == addresses[_MIGRATOR], "not allowed");
require(_amount.length == _destination.length, "mismatching input");
for (uint256 index = 0; index < _destination.length; index++) {
_migrateFor(_destination[index], _amount[index], false);
}
}
/**
* @dev This is an internal function used by the function migrate that helps to
* swap old trb tokens for new ones based on a custom amount
* @param _destination is the address that will receive tokens
* @param _amount is the amount to mint to the user
* @param _bypass is true if the migrator contract needs to bypass the migrated = true flag
* for users that have already migrated
*/
function _migrateFor(
address _destination,
uint256 _amount,
bool _bypass
) internal {
if (!_bypass) require(!migrated[_destination], "already migrated");
_doMint(_destination, _amount);
migrated[_destination] = true;
}
/**
* @dev This function allows users to swap old trb tokens for new ones based
* on the user's old Tellor balance
*/
function migrate() external {
_migrate(msg.sender);
}
/**
* @dev This function allows miners to submit their mining solution and data requested
* @param _nonce is the mining solution
* @param _requestIds are the 5 request ids being mined
* @param _values are the 5 values corresponding to the 5 request ids
*/
function submitMiningSolution(
string calldata _nonce,
uint256[5] calldata _requestIds,
uint256[5] calldata _values
) external {
bytes32 _hashMsgSender = keccak256(abi.encode(msg.sender));
require(
uints[_hashMsgSender] == 0 ||
block.timestamp - uints[_hashMsgSender] > 15 minutes,
"Miner can only win rewards once per 15 min"
);
if (uints[_SLOT_PROGRESS] != 4) {
_verifyNonce(_nonce);
}
uints[_hashMsgSender] = block.timestamp;
_submitMiningSolution(_nonce, _requestIds, _values);
}
/**
* @dev This is an internal function used by submitMiningSolution to allow miners to submit
* their mining solution and data requested. It checks the miner is staked, has not
* won in the last 15 min, and checks they are submitting all the correct requestids
* @param _nonce is the mining solution
* @param _requestIds are the 5 request ids being mined
* @param _values are the 5 values corresponding to the 5 request ids
*/
function _submitMiningSolution(
string memory _nonce,
uint256[5] memory _requestIds,
uint256[5] memory _values
) internal {
//Verifying Miner Eligibility
bytes32 _hashMsgSender = keccak256(abi.encode(msg.sender));
require(
stakerDetails[msg.sender].currentStatus == 1,
"Miner status is not staker"
);
require(
_requestIds[0] == currentMiners[0].value,
"Request ID is wrong"
);
require(
_requestIds[1] == currentMiners[1].value,
"Request ID is wrong"
);
require(
_requestIds[2] == currentMiners[2].value,
"Request ID is wrong"
);
require(
_requestIds[3] == currentMiners[3].value,
"Request ID is wrong"
);
require(
_requestIds[4] == currentMiners[4].value,
"Request ID is wrong"
);
uints[_hashMsgSender] = block.timestamp;
bytes32 _currChallenge = bytesVars[_CURRENT_CHALLENGE];
uint256 _slotP = uints[_SLOT_PROGRESS];
//Checking and updating Miner Status
require(
minersByChallenge[_currChallenge][msg.sender] == false,
"Miner already submitted the value"
);
//Update the miner status to true once they submit a value so they don't submit more than once
minersByChallenge[_currChallenge][msg.sender] = true;
//Updating Request
Request storage _tblock = requestDetails[uints[_T_BLOCK]];
//Assigning directly is cheaper than using a for loop
_tblock.valuesByTimestamp[0][_slotP] = _values[0];
_tblock.valuesByTimestamp[1][_slotP] = _values[1];
_tblock.valuesByTimestamp[2][_slotP] = _values[2];
_tblock.valuesByTimestamp[3][_slotP] = _values[3];
_tblock.valuesByTimestamp[4][_slotP] = _values[4];
_tblock.minersByValue[0][_slotP] = msg.sender;
_tblock.minersByValue[1][_slotP] = msg.sender;
_tblock.minersByValue[2][_slotP] = msg.sender;
_tblock.minersByValue[3][_slotP] = msg.sender;
_tblock.minersByValue[4][_slotP] = msg.sender;
if (_slotP + 1 == 4) {
_adjustDifficulty();
}
emit NonceSubmitted(
msg.sender,
_nonce,
_requestIds,
_values,
_currChallenge,
_slotP
);
if (_slotP + 1 == 5) {
//slotProgress has been incremented, but we're using the variable on stack to save gas
_newBlock(_nonce, _requestIds);
uints[_SLOT_PROGRESS] = 0;
} else {
uints[_SLOT_PROGRESS]++;
}
}
/**
* @dev This is an internal function used by submitMiningSolution to allows miners to submit
* their mining solution and data requested. It checks the miner has submitted a
* valid nonce or allows any solution if 15 minutes or more have passed since last
* mine values
* @param _nonce is the mining solution
*/
function _verifyNonce(string memory _nonce) internal view {
require(
uint256(
sha256(
abi.encodePacked(
ripemd160(
abi.encodePacked(
keccak256(
abi.encodePacked(
bytesVars[_CURRENT_CHALLENGE],
msg.sender,
_nonce
)
)
)
)
)
)
) %
uints[_DIFFICULTY] ==
0 ||
block.timestamp - uints[_TIME_OF_LAST_NEW_VALUE] >= 15 minutes,
"Incorrect nonce for current challenge"
);
}
/**
* @dev This is an internal function used by submitMiningSolution and adjusts the difficulty
* based on the difference between the target time and how long it took to solve
* the previous challenge otherwise it sets it to 1
*/
function _adjustDifficulty() internal {
// If the difference between the timeTarget and how long it takes to solve the challenge this updates the challenge
// difficulty up or down by the difference between the target time and how long it took to solve the previous challenge
// otherwise it sets it to 1
uint256 timeDiff = block.timestamp - uints[_TIME_OF_LAST_NEW_VALUE];
int256 _change = int256(SafeMath.min(1200, timeDiff));
int256 _diff = int256(uints[_DIFFICULTY]);
_change = (_diff * (int256(uints[_TIME_TARGET]) - _change)) / 4000;
if (_change == 0) {
_change = 1;
}
uints[_DIFFICULTY] = uint256(SafeMath.max(_diff + _change, 1));
}
/**
* @dev This is an internal function used by submitMiningSolution to
* calculate and pay rewards to miners
* @param miners are the 5 miners to reward
* @param _previousTime is the previous mine time based on the 4th entry
*/
function _payReward(address[5] memory miners, uint256 _previousTime)
internal
{
//_timeDiff is how many seconds passed since last block
uint256 _timeDiff = block.timestamp - _previousTime;
uint256 reward = (_timeDiff * uints[_CURRENT_REWARD]) / 300;
uint256 _tip = uints[_CURRENT_TOTAL_TIPS] / 10;
uint256 _devShare = reward / 2;
_doMint(miners[0], reward + _tip);
_doMint(miners[1], reward + _tip);
_doMint(miners[2], reward + _tip);
_doMint(miners[3], reward + _tip);
_doMint(miners[4], reward + _tip);
_doMint(addresses[_OWNER], _devShare);
uints[_CURRENT_TOTAL_TIPS] = 0;
}
/**
* @dev This is an internal function called by submitMiningSolution and adjusts the difficulty,
* sorts and stores the first 5 values received, pays the miners, the dev share and
* assigns a new challenge
* @param _nonce or solution for the PoW for the requestId
* @param _requestIds for the current request being mined
*/
function _newBlock(string memory _nonce, uint256[5] memory _requestIds)
internal
{
Request storage _tblock = requestDetails[uints[_T_BLOCK]];
bytes32 _currChallenge = bytesVars[_CURRENT_CHALLENGE];
uint256 _previousTime = uints[_TIME_OF_LAST_NEW_VALUE];
uint256 _timeOfLastNewValueVar = block.timestamp;
uints[_TIME_OF_LAST_NEW_VALUE] = _timeOfLastNewValueVar;
//this loop sorts the values and stores the median as the official value
uint256[5] memory a;
uint256[5] memory b;
for (uint256 k = 0; k < 5; k++) {
for (uint256 i = 1; i < 5; i++) {
uint256 temp = _tblock.valuesByTimestamp[k][i];
address temp2 = _tblock.minersByValue[k][i];
uint256 j = i;
while (j > 0 && temp < _tblock.valuesByTimestamp[k][j - 1]) {
_tblock.valuesByTimestamp[k][j] = _tblock.valuesByTimestamp[
k
][j - 1];
_tblock.minersByValue[k][j] = _tblock.minersByValue[k][
j - 1
];
j--;
}
if (j < i) {
_tblock.valuesByTimestamp[k][j] = temp;
_tblock.minersByValue[k][j] = temp2;
}
}
Request storage _request = requestDetails[_requestIds[k]];
//Save the official(finalValue), timestamp of it, 5 miners and their submitted values for it, and its block number
a = _tblock.valuesByTimestamp[k];
_request.finalValues[_timeOfLastNewValueVar] = a[2];
b[k] = a[2];
_request.minersByValue[_timeOfLastNewValueVar] = _tblock
.minersByValue[k];
_request.valuesByTimestamp[_timeOfLastNewValueVar] = _tblock
.valuesByTimestamp[k];
delete _tblock.minersByValue[k];
delete _tblock.valuesByTimestamp[k];
_request.requestTimestamps.push(_timeOfLastNewValueVar);
_request.minedBlockNum[_timeOfLastNewValueVar] = block.number;
_request.apiUintVars[_TOTAL_TIP] = 0;
}
emit NewValue(
_requestIds,
_timeOfLastNewValueVar,
b,
uints[_CURRENT_TOTAL_TIPS],
_currChallenge
);
//add timeOfLastValue to the newValueTimestamps array
newValueTimestamps.push(_timeOfLastNewValueVar);
address[5] memory miners =
requestDetails[_requestIds[0]].minersByValue[
_timeOfLastNewValueVar
];
//pay Miners Rewards
_payReward(miners, _previousTime);
uints[_T_BLOCK]++;
uint256[5] memory _topId = _getTopRequestIDs();
for (uint256 i = 0; i < 5; i++) {
currentMiners[i].value = _topId[i];
requestQ[
requestDetails[_topId[i]].apiUintVars[_REQUEST_Q_POSITION]
] = 0;
uints[_CURRENT_TOTAL_TIPS] += requestDetails[_topId[i]].apiUintVars[
_TOTAL_TIP
];
}
// Issue the next challenge
_currChallenge = keccak256(
abi.encode(_nonce, _currChallenge, blockhash(block.number - 1))
);
bytesVars[_CURRENT_CHALLENGE] = _currChallenge; // Save hash for next proof
emit NewChallenge(
_currChallenge,
_topId,
uints[_DIFFICULTY],
uints[_CURRENT_TOTAL_TIPS]
);
}
/**
* @dev Add tip to Request value from oracle
* @param _requestId being requested to be mined
* @param _tip amount the requester is willing to pay to be get on queue. Miners
* mine the onDeckQueryHash, or the api with the highest payout pool
*/
function addTip(uint256 _requestId, uint256 _tip) external {
require(_requestId != 0, "RequestId is 0");
require(_tip != 0, "Tip should be greater than 0");
uint256 _count = uints[_REQUEST_COUNT] + 1;
if (_requestId == _count) {
uints[_REQUEST_COUNT] = _count;
} else {
require(_requestId < _count, "RequestId is not less than count");
}
_doBurn(msg.sender, _tip);
//Update the information for the request that should be mined next based on the tip submitted
updateOnDeck(_requestId, _tip);
emit TipAdded(
msg.sender,
_requestId,
_tip,
requestDetails[_requestId].apiUintVars[_TOTAL_TIP]
);
}
/**
* @dev This function updates the requestQ when addTip are ran
* @param _requestId being requested
* @param _tip is the tip to add
*/
function updateOnDeck(uint256 _requestId, uint256 _tip) internal {
Request storage _request = requestDetails[_requestId];
_request.apiUintVars[_TOTAL_TIP] = _request.apiUintVars[_TOTAL_TIP].add(
_tip
);
if (
currentMiners[0].value == _requestId ||
currentMiners[1].value == _requestId ||
currentMiners[2].value == _requestId ||
currentMiners[3].value == _requestId ||
currentMiners[4].value == _requestId
) {
uints[_CURRENT_TOTAL_TIPS] += _tip;
} else {
// if the request is not part of the requestQ[51] array
// then add to the requestQ[51] only if the _payout/tip is greater than the minimum(tip) in the requestQ[51] array
if (_request.apiUintVars[_REQUEST_Q_POSITION] == 0) {
uint256 _min;
uint256 _index;
(_min, _index) = _getMin(requestQ);
//we have to zero out the oldOne
//if the _payout is greater than the current minimum payout in the requestQ[51] or if the minimum is zero
//then add it to the requestQ array and map its index information to the requestId and the apiUintVars
if (_request.apiUintVars[_TOTAL_TIP] > _min || _min == 0) {
requestQ[_index] = _request.apiUintVars[_TOTAL_TIP];
requestDetails[requestIdByRequestQIndex[_index]]
.apiUintVars[_REQUEST_Q_POSITION] = 0;
requestIdByRequestQIndex[_index] = _requestId;
_request.apiUintVars[_REQUEST_Q_POSITION] = _index;
}
// else if the requestId is part of the requestQ[51] then update the tip for it
} else {
requestQ[_request.apiUintVars[_REQUEST_Q_POSITION]] += _tip;
}
}
}
/**
* @dev This is an internal function called by updateOnDeck that gets the min value
* @param data is an array [51] to determine the min from
* @return min the min value and it's index in the data array
*/
function _getMin(uint256[51] memory data)
internal
pure
returns (uint256 min, uint256 minIndex)
{
minIndex = data.length - 1;
min = data[minIndex];
for (uint256 i = data.length - 2; i > 0; i--) {
if (data[i] < min) {
min = data[i];
minIndex = i;
}
}
}
/**
* @dev This is an internal function called by updateOnDeck that gets the top 5 values
* @param data is an array [51] to determine the top 5 values from
* @return max the top 5 values and their index values in the data array
*/
function _getMax5(uint256[51] memory data)
internal
pure
returns (uint256[5] memory max, uint256[5] memory maxIndex)
{
uint256 min5 = data[1];
uint256 minI = 0;
for (uint256 j = 0; j < 5; j++) {
max[j] = data[j + 1]; //max[0]=data[1]
maxIndex[j] = j + 1; //maxIndex[0]= 1
if (max[j] < min5) {
min5 = max[j];
minI = j;
}
}
for (uint256 i = 6; i < data.length; i++) {
if (data[i] > min5) {
max[minI] = data[i];
maxIndex[minI] = i;
min5 = data[i];
for (uint256 j = 0; j < 5; j++) {
if (max[j] < min5) {
min5 = max[j];
minI = j;
}
}
}
}
}
/**
* @dev Getter function for the top 5 requests with highest payouts.
* This function is used within the newBlock function
* @return _requestIds the top 5 requests ids based on tips or the last 5 requests ids mined
*/
function _getTopRequestIDs()
internal
view
returns (uint256[5] memory _requestIds)
{
uint256[5] memory _max;
uint256[5] memory _index;
(_max, _index) = _getMax5(requestQ);
for (uint256 i = 0; i < 5; i++) {
if (_max[i] != 0) {
_requestIds[i] = requestIdByRequestQIndex[_index[i]];
} else {
_requestIds[i] = currentMiners[4 - i].value;
}
}
}
/**
* @dev This is an internal function called within the fallback function to help delegate calls.
* This functions helps delegate calls to the TellorGetters
* contract.
*/
function _delegate(address implementation)
internal
virtual
returns (bool succ, bytes memory ret)
{
(succ, ret) = implementation.delegatecall(msg.data);
}
/**
* @dev The tellor logic does not fit in one contract so it has been split into two:
* Tellor and TellorGetters This functions helps delegate calls to the TellorGetters
* contract.
*/
fallback() external payable {
address addr = addresses[_EXTENSION];
(bool result, ) = _delegate(addr);
assembly {
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "./TellorTransfer.sol";
import "./TellorGetters.sol";
import "./Extension.sol";
import "./Utilities.sol";
/**
* title Tellor Stake
* @dev Contains the methods related to initiating disputes and
* voting on them.
* Because of space limitations some functions are currently on the Extensions contract
*/
contract TellorStake is TellorTransfer {
using SafeMath for uint256;
using SafeMath for int256;
//emitted when a new dispute is initialized
event NewDispute(
uint256 indexed _disputeId,
uint256 indexed _requestId,
uint256 _timestamp,
address _miner
);
//emitted when a new vote happens
event Voted(
uint256 indexed _disputeID,
bool _position,
address indexed _voter,
uint256 indexed _voteWeight
);
/**
* @dev Helps initialize a dispute by assigning it a disputeId
* when a miner returns a false/bad value on the validate array(in Tellor.ProofOfWork) it sends the
* invalidated value information to POS voting
* @param _requestId being disputed
* @param _timestamp being disputed
* @param _minerIndex the index of the miner that submitted the value being disputed. Since each official value
* requires 5 miners to submit a value.
*/
function beginDispute(
uint256 _requestId,
uint256 _timestamp,
uint256 _minerIndex
) public {
Request storage _request = requestDetails[_requestId];
require(_request.minedBlockNum[_timestamp] != 0, "Mined block is 0");
require(_minerIndex < 5, "Miner index is wrong");
//_miner is the miner being disputed. For every mined value 5 miners are saved in an array and the _minerIndex
//provided by the party initiating the dispute
address _miner = _request.minersByValue[_timestamp][_minerIndex];
bytes32 _hash =
keccak256(abi.encodePacked(_miner, _requestId, _timestamp));
//Increase the dispute count by 1
uint256 disputeId = uints[_DISPUTE_COUNT] + 1;
uints[_DISPUTE_COUNT] = disputeId;
//Ensures that a dispute is not already open for the that miner, requestId and timestamp
uint256 hashId = disputeIdByDisputeHash[_hash];
if (hashId != 0) {
disputesById[disputeId].disputeUintVars[_ORIGINAL_ID] = hashId;
} else {
disputeIdByDisputeHash[_hash] = disputeId;
hashId = disputeId;
}
uint256 origID = hashId;
uint256 dispRounds =
disputesById[origID].disputeUintVars[_DISPUTE_ROUNDS] + 1;
disputesById[origID].disputeUintVars[_DISPUTE_ROUNDS] = dispRounds;
disputesById[origID].disputeUintVars[
keccak256(abi.encode(dispRounds))
] = disputeId;
if (disputeId != origID) {
uint256 lastID =
disputesById[origID].disputeUintVars[
keccak256(abi.encode(dispRounds - 1))
];
require(
disputesById[lastID].disputeUintVars[_MIN_EXECUTION_DATE] <=
block.timestamp,
"Dispute is already open"
);
if (disputesById[lastID].executed) {
require(
block.timestamp -
disputesById[lastID].disputeUintVars[_TALLY_DATE] <=
1 days,
"Time for voting haven't elapsed"
);
}
}
uint256 _fee;
if (_minerIndex == 2) {
requestDetails[_requestId].apiUintVars[_DISPUTE_COUNT] =
requestDetails[_requestId].apiUintVars[_DISPUTE_COUNT] +
1;
//update dispute fee for this case
_fee =
uints[_STAKE_AMOUNT] *
requestDetails[_requestId].apiUintVars[_DISPUTE_COUNT];
} else {
_fee = uints[_DISPUTE_FEE] * dispRounds;
}
//maps the dispute to the Dispute struct
disputesById[disputeId].hash = _hash;
disputesById[disputeId].isPropFork = false;
disputesById[disputeId].reportedMiner = _miner;
disputesById[disputeId].reportingParty = msg.sender;
disputesById[disputeId].proposedForkAddress = address(0);
disputesById[disputeId].executed = false;
disputesById[disputeId].disputeVotePassed = false;
disputesById[disputeId].tally = 0;
//Saves all the dispute variables for the disputeId
disputesById[disputeId].disputeUintVars[_REQUEST_ID] = _requestId;
disputesById[disputeId].disputeUintVars[_TIMESTAMP] = _timestamp;
disputesById[disputeId].disputeUintVars[_VALUE] = _request
.valuesByTimestamp[_timestamp][_minerIndex];
disputesById[disputeId].disputeUintVars[_MIN_EXECUTION_DATE] =
block.timestamp +
2 days *
dispRounds;
disputesById[disputeId].disputeUintVars[_BLOCK_NUMBER] = block.number;
disputesById[disputeId].disputeUintVars[_MINER_SLOT] = _minerIndex;
disputesById[disputeId].disputeUintVars[_FEE] = _fee;
_doTransfer(msg.sender, address(this), _fee);
//Values are sorted as they come in and the official value is the median of the first five
//So the "official value" miner is always minerIndex==2. If the official value is being
//disputed, it sets its status to inDispute(currentStatus = 3) so that users are made aware it is under dispute
if (_minerIndex == 2) {
_request.inDispute[_timestamp] = true;
_request.finalValues[_timestamp] = 0;
}
stakerDetails[_miner].currentStatus = 3;
emit NewDispute(disputeId, _requestId, _timestamp, _miner);
}
/**
* @dev Allows token holders to vote
* @param _disputeId is the dispute id
* @param _supportsDispute is the vote (true=the dispute has basis false = vote against dispute)
*/
function vote(uint256 _disputeId, bool _supportsDispute) public {
Dispute storage disp = disputesById[_disputeId];
//Get the voteWeight or the balance of the user at the time/blockNumber the dispute began
uint256 voteWeight =
balanceOfAt(msg.sender, disp.disputeUintVars[_BLOCK_NUMBER]);
//Require that the msg.sender has not voted
require(disp.voted[msg.sender] != true, "Sender has already voted");
//Require that the user had a balance >0 at time/blockNumber the dispute began
require(voteWeight != 0, "User balance is 0");
//ensures miners that are under dispute cannot vote
require(
stakerDetails[msg.sender].currentStatus != 3,
"Miner is under dispute"
);
//Update user voting status to true
disp.voted[msg.sender] = true;
//Update the number of votes for the dispute
disp.disputeUintVars[_NUM_OF_VOTES] += 1;
//If the user supports the dispute increase the tally for the dispute by the voteWeight
//otherwise decrease it
if (_supportsDispute) {
disp.tally = disp.tally.add(int256(voteWeight));
} else {
disp.tally = disp.tally.sub(int256(voteWeight));
}
//Let the network kblock.timestamp the user has voted on the dispute and their casted vote
emit Voted(_disputeId, _supportsDispute, msg.sender, voteWeight);
}
/**
* @dev Allows disputer to unlock the dispute fee
* @param _disputeId to unlock fee from
*/
function unlockDisputeFee(uint256 _disputeId) public {
uint256 origID = disputeIdByDisputeHash[disputesById[_disputeId].hash];
uint256 lastID =
disputesById[origID].disputeUintVars[
keccak256(
abi.encode(
disputesById[origID].disputeUintVars[_DISPUTE_ROUNDS]
)
)
];
if (lastID == 0) {
lastID = origID;
}
Dispute storage disp = disputesById[origID];
Dispute storage last = disputesById[lastID];
//disputeRounds is increased by 1 so that the _id is not a negative number when it is the first time a dispute is initiated
uint256 dispRounds = disp.disputeUintVars[_DISPUTE_ROUNDS];
if (dispRounds == 0) {
dispRounds = 1;
}
uint256 _id;
require(disp.disputeUintVars[_PAID] == 0, "already paid out");
require(
block.timestamp - last.disputeUintVars[_TALLY_DATE] > 1 days,
"Time for voting haven't elapsed"
);
StakeInfo storage stakes = stakerDetails[disp.reportedMiner];
disp.disputeUintVars[_PAID] = 1;
if (last.disputeVotePassed == true) {
//Changing the currentStatus and startDate unstakes the reported miner and transfers the stakeAmount
stakes.startDate = block.timestamp - (block.timestamp % 86400);
//Reduce the staker count
uints[_STAKE_COUNT] -= 1;
//Update the minimum dispute fee that is based on the number of
// Not ideal, but allows to keep updateMinDosputeFee in the extension contract
addresses[_EXTENSION].delegatecall(
abi.encodeWithSignature("updateMinDisputeFee")
);
//Decreases the stakerCount since the miner's stake is being slashed
if (stakes.currentStatus == 4) {
stakes.currentStatus = 5;
_doTransfer(
disp.reportedMiner,
disp.reportingParty,
uints[_STAKE_AMOUNT]
);
stakes.currentStatus = 0;
}
for (uint256 i = 0; i < dispRounds; i++) {
_id = disp.disputeUintVars[
keccak256(abi.encode(dispRounds - i))
];
if (_id == 0) {
_id = origID;
}
Dispute storage disp2 = disputesById[_id];
//transfer fee adjusted based on number of miners if the minerIndex is not 2(official value)
_doTransfer(
address(this),
disp2.reportingParty,
disp2.disputeUintVars[_FEE]
);
}
} else {
stakes.currentStatus = 1;
TellorStorage.Request storage _request =
requestDetails[disp.disputeUintVars[_REQUEST_ID]];
if (disp.disputeUintVars[_MINER_SLOT] == 2) {
//note we still don't put timestamp back into array (is this an issue? (shouldn't be))
_request.finalValues[disp.disputeUintVars[_TIMESTAMP]] = disp
.disputeUintVars[_VALUE];
}
if (_request.inDispute[disp.disputeUintVars[_TIMESTAMP]] == true) {
_request.inDispute[disp.disputeUintVars[_TIMESTAMP]] = false;
}
for (uint256 i = 0; i < dispRounds; i++) {
_id = disp.disputeUintVars[
keccak256(abi.encode(dispRounds - i))
];
if (_id != 0) {
last = disputesById[_id]; //handling if happens during an upgrade
}
_doTransfer(
address(this),
last.reportedMiner,
disputesById[_id].disputeUintVars[_FEE]
);
}
}
if (disp.disputeUintVars[_MINER_SLOT] == 2) {
requestDetails[disp.disputeUintVars[_REQUEST_ID]].apiUintVars[
_DISPUTE_COUNT
]--;
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "./SafeMath.sol";
import "./TellorStorage.sol";
import "./TellorVariables.sol";
import "./Utilities.sol";
/**
* @title Tellor Getters
* @dev Oracle contract with all tellor getter functions
*/
contract TellorGetters is TellorStorage, TellorVariables, Utilities {
using SafeMath for uint256;
/**
* @dev This function tells you if a given challenge has been completed by a given miner
* @param _challenge the challenge to search for
* @param _miner address that you want to know if they solved the challenge
* @return true if the _miner address provided solved the
*/
function didMine(bytes32 _challenge, address _miner)
public
view
returns (bool)
{
return minersByChallenge[_challenge][_miner];
}
/**
* @dev Checks if an address voted in a given dispute
* @param _disputeId to look up
* @param _address to look up
* @return bool of whether or not party voted
*/
function didVote(uint256 _disputeId, address _address)
external
view
returns (bool)
{
return disputesById[_disputeId].voted[_address];
}
/**
* @dev allows Tellor to read data from the addressVars mapping
* @param _data is the keccak256("variable_name") of the variable that is being accessed.
* These are examples of how the variables are saved within other functions:
* addressVars[keccak256("_owner")]
* addressVars[keccak256("tellorContract")]
* @return address of the requested variable
*/
function getAddressVars(bytes32 _data) external view returns (address) {
return addresses[_data];
}
/**
* @dev Gets all dispute variables
* @param _disputeId to look up
* @return bytes32 hash of dispute
* bool executed where true if it has been voted on
* bool disputeVotePassed
* bool isPropFork true if the dispute is a proposed fork
* address of reportedMiner
* address of reportingParty
* address of proposedForkAddress
* uint of requestId
* uint of timestamp
* uint of value
* uint of minExecutionDate
* uint of numberOfVotes
* uint of blocknumber
* uint of minerSlot
* uint of quorum
* uint of fee
* int count of the current tally
*/
function getAllDisputeVars(uint256 _disputeId)
public
view
returns (
bytes32,
bool,
bool,
bool,
address,
address,
address,
uint256[9] memory,
int256
)
{
Dispute storage disp = disputesById[_disputeId];
return (
disp.hash,
disp.executed,
disp.disputeVotePassed,
disp.isPropFork,
disp.reportedMiner,
disp.reportingParty,
disp.proposedForkAddress,
[
disp.disputeUintVars[_REQUEST_ID],
disp.disputeUintVars[_TIMESTAMP],
disp.disputeUintVars[_VALUE],
disp.disputeUintVars[_MIN_EXECUTION_DATE],
disp.disputeUintVars[_NUM_OF_VOTES],
disp.disputeUintVars[_BLOCK_NUMBER],
disp.disputeUintVars[_MINER_SLOT],
disp.disputeUintVars[keccak256("quorum")],
disp.disputeUintVars[_FEE]
],
disp.tally
);
}
/**
* @dev Checks if a given hash of miner,requestId has been disputed
* @param _hash is the sha256(abi.encodePacked(_miners[2],_requestId,_timestamp));
* @return uint disputeId
*/
function getDisputeIdByDisputeHash(bytes32 _hash)
external
view
returns (uint256)
{
return disputeIdByDisputeHash[_hash];
}
/**
* @dev Checks for uint variables in the disputeUintVars mapping based on the disputeId
* @param _disputeId is the dispute id;
* @param _data the variable to pull from the mapping. _data = keccak256("variable_name") where variable_name is
* the variables/strings used to save the data in the mapping. The variables names are
* commented out under the disputeUintVars under the Dispute struct
* @return uint value for the bytes32 data submitted
*/
function getDisputeUintVars(uint256 _disputeId, bytes32 _data)
external
view
returns (uint256)
{
return disputesById[_disputeId].disputeUintVars[_data];
}
/**
* @dev Gets the a value for the latest timestamp available
* @return value for timestamp of last proof of work submitted
* @return true if the is a timestamp for the lastNewValue
*/
function getLastNewValue() external view returns (uint256, bool) {
return (
retrieveData(
requestIdByTimestamp[uints[_TIME_OF_LAST_NEW_VALUE]],
uints[_TIME_OF_LAST_NEW_VALUE]
),
true
);
}
/**
* @dev Gets the a value for the latest timestamp available
* @param _requestId being requested
* @return value for timestamp of last proof of work submitted and if true if it exist or 0 and false if it doesn't
*/
function getLastNewValueById(uint256 _requestId)
external
view
returns (uint256, bool)
{
Request storage _request = requestDetails[_requestId];
if (_request.requestTimestamps.length != 0) {
return (
retrieveData(
_requestId,
_request.requestTimestamps[
_request.requestTimestamps.length - 1
]
),
true
);
} else {
return (0, false);
}
}
/**
* @dev Gets blocknumber for mined timestamp
* @param _requestId to look up
* @param _timestamp is the timestamp to look up blocknumber
* @return uint of the blocknumber which the dispute was mined
*/
function getMinedBlockNum(uint256 _requestId, uint256 _timestamp)
external
view
returns (uint256)
{
return requestDetails[_requestId].minedBlockNum[_timestamp];
}
/**
* @dev Gets the 5 miners who mined the value for the specified requestId/_timestamp
* @param _requestId to look up
* @param _timestamp is the timestamp to look up miners for
* @return the 5 miners' addresses
*/
function getMinersByRequestIdAndTimestamp(
uint256 _requestId,
uint256 _timestamp
) external view returns (address[5] memory) {
return requestDetails[_requestId].minersByValue[_timestamp];
}
/**
* @dev Counts the number of values that have been submitted for the request
* if called for the currentRequest being mined it can tell you how many miners have submitted a value for that
* request so far
* @param _requestId the requestId to look up
* @return uint count of the number of values received for the requestId
*/
function getNewValueCountbyRequestId(uint256 _requestId)
external
view
returns (uint256)
{
return requestDetails[_requestId].requestTimestamps.length;
}
/**
* @dev Getter function for the specified requestQ index
* @param _index to look up in the requestQ array
* @return uint of requestId
*/
function getRequestIdByRequestQIndex(uint256 _index)
external
view
returns (uint256)
{
require(_index <= 50, "RequestQ index is above 50");
return requestIdByRequestQIndex[_index];
}
/**
* @dev Getter function for requestId based on timestamp
* @param _timestamp to check requestId
* @return uint of requestId
*/
function getRequestIdByTimestamp(uint256 _timestamp)
external
view
returns (uint256)
{
return requestIdByTimestamp[_timestamp];
}
/**
* @dev Getter function for the requestQ array
* @return the requestQ array
*/
function getRequestQ() public view returns (uint256[51] memory) {
return requestQ;
}
/**
* @dev Allows access to the uint variables saved in the apiUintVars under the requestDetails struct
* for the requestId specified
* @param _requestId to look up
* @param _data the variable to pull from the mapping. _data = keccak256("variable_name") where variable_name is
* the variables/strings used to save the data in the mapping. The variables names are
* commented out under the apiUintVars under the requestDetails struct
* @return uint value of the apiUintVars specified in _data for the requestId specified
*/
function getRequestUintVars(uint256 _requestId, bytes32 _data)
external
view
returns (uint256)
{
return requestDetails[_requestId].apiUintVars[_data];
}
/**
* @dev Gets the API struct variables that are not mappings
* @param _requestId to look up
* @return uint of index in requestQ array
* @return uint of current payout/tip for this requestId
*/
function getRequestVars(uint256 _requestId)
external
view
returns (uint256, uint256)
{
Request storage _request = requestDetails[_requestId];
return (
_request.apiUintVars[_REQUEST_Q_POSITION],
_request.apiUintVars[_TOTAL_TIP]
);
}
/**
* @dev This function allows users to retrieve all information about a staker
* @param _staker address of staker inquiring about
* @return uint current state of staker
* @return uint startDate of staking
*/
function getStakerInfo(address _staker)
external
view
returns (uint256, uint256)
{
return (
stakerDetails[_staker].currentStatus,
stakerDetails[_staker].startDate
);
}
/**
* @dev Gets the 5 miners who mined the value for the specified requestId/_timestamp
* @param _requestId to look up
* @param _timestamp is the timestamp to look up miners for
* @return address[5] array of 5 addresses of miners that mined the requestId
*/
function getSubmissionsByTimestamp(uint256 _requestId, uint256 _timestamp)
external
view
returns (uint256[5] memory)
{
return requestDetails[_requestId].valuesByTimestamp[_timestamp];
}
/**
* @dev Gets the timestamp for the value based on their index
* @param _requestID is the requestId to look up
* @param _index is the value index to look up
* @return uint timestamp
*/
function getTimestampbyRequestIDandIndex(uint256 _requestID, uint256 _index)
external
view
returns (uint256)
{
return requestDetails[_requestID].requestTimestamps[_index];
}
/**
* @dev Getter for the variables saved under the TellorStorageStruct uints variable
* @param _data the variable to pull from the mapping. _data = keccak256("variable_name")
* where variable_name is the variables/strings used to save the data in the mapping.
* The variables names in the TellorVariables contract
* @return uint of specified variable
*/
function getUintVar(bytes32 _data) public view returns (uint256) {
return uints[_data];
}
/**
* @dev Gets the 5 miners who mined the value for the specified requestId/_timestamp
* @param _requestId to look up
* @param _timestamp is the timestamp to look up miners for
* @return bool true if requestId/timestamp is under dispute
*/
function isInDispute(uint256 _requestId, uint256 _timestamp)
external
view
returns (bool)
{
return requestDetails[_requestId].inDispute[_timestamp];
}
/**
* @dev Retrieve value from oracle based on timestamp
* @param _requestId being requested
* @param _timestamp to retrieve data/value from
* @return value for timestamp submitted
*/
function retrieveData(uint256 _requestId, uint256 _timestamp)
public
view
returns (uint256)
{
return requestDetails[_requestId].finalValues[_timestamp];
}
/**
* @dev Getter for the total_supply of oracle tokens
* @return uint total supply
*/
function totalSupply() external view returns (uint256) {
return uints[_TOTAL_SUPPLY];
}
/**
* @dev Allows users to access the token's name
*/
function name() external pure returns (string memory) {
return "Tellor Tributes";
}
/**
* @dev Allows users to access the token's symbol
*/
function symbol() external pure returns (string memory) {
return "TRB";
}
/**
* @dev Allows users to access the number of decimals
*/
function decimals() external pure returns (uint8) {
return 18;
}
/**
* @dev Getter function for the requestId being mined
* returns the currentChallenge, array of requestIDs, difficulty, and the current Tip of the 5 IDs
*/
function getNewCurrentVariables()
external
view
returns (
bytes32 _challenge,
uint256[5] memory _requestIds,
uint256 _diff,
uint256 _tip
)
{
for (uint256 i = 0; i < 5; i++) {
_requestIds[i] = currentMiners[i].value;
}
return (
bytesVars[_CURRENT_CHALLENGE],
_requestIds,
uints[_DIFFICULTY],
uints[_CURRENT_TOTAL_TIPS]
);
}
/**
* @dev Getter function for next requestIds on queue/request with highest payouts at time the function is called
*/
function getNewVariablesOnDeck()
external
view
returns (uint256[5] memory idsOnDeck, uint256[5] memory tipsOnDeck)
{
idsOnDeck = getTopRequestIDs();
for (uint256 i = 0; i < 5; i++) {
tipsOnDeck[i] = requestDetails[idsOnDeck[i]].apiUintVars[
_TOTAL_TIP
];
}
}
/**
* @dev Getter function for the top 5 requests with highest payouts. This function is used within the getNewVariablesOnDeck function
*/
function getTopRequestIDs()
public
view
returns (uint256[5] memory _requestIds)
{
uint256[5] memory _max;
uint256[5] memory _index;
(_max, _index) = getMax5(requestQ);
for (uint256 i = 0; i < 5; i++) {
if (_max[i] != 0) {
_requestIds[i] = requestIdByRequestQIndex[_index[i]];
} else {
_requestIds[i] = currentMiners[4 - i].value;
}
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
//Functions for retrieving min and Max in 51 length array (requestQ)
//Taken partly from: https://github.com/modular-network/ethereum-libraries-array-utils/blob/master/contracts/Array256Lib.sol
contract Utilities {
/**
* @dev This is an internal function called by updateOnDeck that gets the top 5 values
* @param data is an array [51] to determine the top 5 values from
* @return max the top 5 values and their index values in the data array
*/
function getMax5(uint256[51] memory data)
public
view
returns (uint256[5] memory max, uint256[5] memory maxIndex)
{
uint256 min5 = data[1];
uint256 minI = 0;
for (uint256 j = 0; j < 5; j++) {
max[j] = data[j + 1]; //max[0]=data[1]
maxIndex[j] = j + 1; //maxIndex[0]= 1
if (max[j] < min5) {
min5 = max[j];
minI = j;
}
}
for (uint256 i = 6; i < data.length; i++) {
if (data[i] > min5) {
max[minI] = data[i];
maxIndex[minI] = i;
min5 = data[i];
for (uint256 j = 0; j < 5; j++) {
if (max[j] < min5) {
min5 = max[j];
minI = j;
}
}
}
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
interface ITellor {
event NewTellorAddress(address _newTellor);
event NewDispute(
uint256 indexed _disputeId,
uint256 indexed _requestId,
uint256 _timestamp,
address _miner
);
event Voted(
uint256 indexed _disputeID,
bool _position,
address indexed _voter,
uint256 indexed _voteWeight
);
event DisputeVoteTallied(
uint256 indexed _disputeID,
int256 _result,
address indexed _reportedMiner,
address _reportingParty,
bool _active
);
event TipAdded(
address indexed _sender,
uint256 indexed _requestId,
uint256 _tip,
uint256 _totalTips
);
event NewChallenge(
bytes32 indexed _currentChallenge,
uint256[5] _currentRequestId,
uint256 _difficulty,
uint256 _totalTips
);
event NewValue(
uint256[5] _requestId,
uint256 _time,
uint256[5] _value,
uint256 _totalTips,
bytes32 indexed _currentChallenge
);
event NonceSubmitted(
address indexed _miner,
string _nonce,
uint256[5] _requestId,
uint256[5] _value,
bytes32 indexed _currentChallenge
);
event OwnershipTransferred(
address indexed _previousOwner,
address indexed _newOwner
);
event OwnershipProposed(
address indexed _previousOwner,
address indexed _newOwner
);
event NewStake(address indexed _sender); //Emits upon new staker
event StakeWithdrawn(address indexed _sender); //Emits when a staker is now no longer staked
event StakeWithdrawRequested(address indexed _sender); //Emits when a staker begins the 7 day withdraw period
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value
); //ERC20 Approval event
event Transfer(address indexed _from, address indexed _to, uint256 _value); //ERC20 Transfer Event
function changeDeity(address _newDeity) external;
function changeTellorContract(address _tellorContract) external;
function allowance(address _user, address _spender)
external
view
returns (uint256);
function allowedToTrade(address _user, uint256 _amount)
external
view
returns (bool);
function balanceOf(address _user) external view returns (uint256);
function balanceOfAt(address _user, uint256 _blockNumber)
external
view
returns (uint256);
function didMine(bytes32 _challenge, address _miner)
external
view
returns (bool);
function didVote(uint256 _disputeId, address _address)
external
view
returns (bool);
function getAddressVars(bytes32 _data) external view returns (address);
function getAllDisputeVars(uint256 _disputeId)
external
view
returns (
bytes32,
bool,
bool,
bool,
address,
address,
address,
uint256[9] memory,
int256
);
function getCurrentVariables()
external
view
returns (
bytes32,
uint256,
uint256,
string memory,
uint256,
uint256
);
function getDisputeIdByDisputeHash(bytes32 _hash)
external
view
returns (uint256);
function getDisputeUintVars(uint256 _disputeId, bytes32 _data)
external
view
returns (uint256);
function getLastNewValue() external view returns (uint256, bool);
function getLastNewValueById(uint256 _requestId)
external
view
returns (uint256, bool);
function getMinedBlockNum(uint256 _requestId, uint256 _timestamp)
external
view
returns (uint256);
function getMinersByRequestIdAndTimestamp(
uint256 _requestId,
uint256 _timestamp
) external view returns (address[5] memory);
function getNewValueCountbyRequestId(uint256 _requestId)
external
view
returns (uint256);
function getRequestIdByRequestQIndex(uint256 _index)
external
view
returns (uint256);
function getRequestIdByTimestamp(uint256 _timestamp)
external
view
returns (uint256);
function getRequestIdByQueryHash(bytes32 _request)
external
view
returns (uint256);
function getRequestQ() external view returns (uint256[51] memory);
function getRequestUintVars(uint256 _requestId, bytes32 _data)
external
view
returns (uint256);
function getRequestVars(uint256 _requestId)
external
view
returns (uint256, uint256);
function getStakerInfo(address _staker)
external
view
returns (uint256, uint256);
function getSubmissionsByTimestamp(uint256 _requestId, uint256 _timestamp)
external
view
returns (uint256[5] memory);
function getTimestampbyRequestIDandIndex(uint256 _requestID, uint256 _index)
external
view
returns (uint256);
function getUintVar(bytes32 _data) external view returns (uint256);
function getVariablesOnDeck()
external
view
returns (
uint256,
uint256,
string memory
);
function isInDispute(uint256 _requestId, uint256 _timestamp)
external
view
returns (bool);
function retrieveData(uint256 _requestId, uint256 _timestamp)
external
view
returns (uint256);
function totalSupply() external view returns (uint256);
function beginDispute(
uint256 _requestId,
uint256 _timestamp,
uint256 _minerIndex
) external;
function vote(uint256 _disputeId, bool _supportsDispute) external;
function tallyVotes(uint256 _disputeId) external;
function proposeFork(address _propNewTellorAddress) external;
function addTip(uint256 _requestId, uint256 _tip) external;
function submitMiningSolution(
string calldata _nonce,
uint256[5] calldata _requestId,
uint256[5] calldata _value
) external;
function proposeOwnership(address payable _pendingOwner) external;
function claimOwnership() external;
function depositStake() external;
function requestStakingWithdraw() external;
function withdrawStake() external;
function approve(address _spender, uint256 _amount) external returns (bool);
function transfer(address _to, uint256 _amount) external returns (bool);
function transferFrom(
address _from,
address _to,
uint256 _amount
) external returns (bool);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function getNewCurrentVariables()
external
view
returns (
bytes32 _challenge,
uint256[5] memory _requestIds,
uint256 _difficutly,
uint256 _tip
);
function getTopRequestIDs()
external
view
returns (uint256[5] memory _requestIds);
function getNewVariablesOnDeck()
external
view
returns (uint256[5] memory idsOnDeck, uint256[5] memory tipsOnDeck);
function updateTellor(uint256 _disputeId) external;
function unlockDisputeFee(uint256 _disputeId) external;
//Test Functions
function theLazyCoon(address _address, uint256 _amount) external;
function testSubmitMiningSolution(
string calldata _nonce,
uint256[5] calldata _requestId,
uint256[5] calldata _value
) external;
function manuallySetDifficulty(uint256 _diff) external;
function migrate() external;
function getMax(uint256[51] memory data)
external
view
returns (uint256 max, uint256 maxIndex);
function getMin(uint256[51] memory data)
external
view
returns (uint256 min, uint256 minIndex);
function getMax5(uint256[51] memory data)
external
view
returns (uint256[5] memory max, uint256[5] memory maxIndex);
function changeExtension(address _ext) external;
function changeMigrator(address _migrator) external;
function getAddressVarByString(string calldata _data)
external
view
returns (address);
function migrateFrom(
address _origin,
address _destination,
uint256 _amount,
bool _bypass
) external;
function migrateFor(
address _destination,
uint256 _amount,
bool _bypass
) external;
function migrateForBatch(
address[] calldata _destination,
uint256[] calldata _amount
) external;
function migrateFromBatch(
address[] calldata _origin,
address[] calldata _destination,
uint256[] calldata _amount
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
//Slightly modified SafeMath library - includes a min and max function, removes useless div function
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256 c) {
if (b > 0) {
c = a + b;
assert(c >= a);
} else {
c = a + b;
assert(c <= a);
}
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function max(int256 a, int256 b) internal pure returns (uint256) {
return a > b ? uint256(a) : uint256(b);
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function sub(int256 a, int256 b) internal pure returns (int256 c) {
if (b > 0) {
c = a - b;
assert(c <= a);
} else {
c = a - b;
assert(c >= a);
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "./SafeMath.sol";
import "./TellorStorage.sol";
import "./TellorVariables.sol";
/**
* @title Tellor Transfer
* @dev Contains the methods related to transfers and ERC20, its storage and hashes of tellor variable
* that are used to save gas on transactions.
*/
contract TellorTransfer is TellorStorage, TellorVariables {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
/*Functions*/
/**
* @dev Allows for a transfer of tokens to _to
* @param _to The address to send tokens to
* @param _amount The amount of tokens to send
*/
function transfer(address _to, uint256 _amount)
public
returns (bool success)
{
_doTransfer(msg.sender, _to, _amount);
return true;
}
/**
* @notice Send _amount tokens to _to from _from on the condition it
* is approved by _from
* @param _from The address holding the tokens being transferred
* @param _to The address of the recipient
* @param _amount The amount of tokens to be transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _amount
) public returns (bool success) {
require(
_allowances[_from][msg.sender] >= _amount,
"Allowance is wrong"
);
_allowances[_from][msg.sender] -= _amount;
_doTransfer(_from, _to, _amount);
return true;
}
/**
* @dev This function approves a _spender an _amount of tokens to use
* @param _spender address
* @param _amount amount the spender is being approved for
* @return true if spender approved successfully
*/
function approve(address _spender, uint256 _amount) public returns (bool) {
require(
msg.sender != address(0),
"ERC20: approve from the zero address"
);
require(_spender != address(0), "ERC20: approve to the zero address");
_allowances[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
/**
* @dev Getter function for remaining spender balance
* @param _user address of party with the balance
* @param _spender address of spender of parties said balance
* @return Returns the remaining allowance of tokens granted to the _spender from the _user
*/
function allowance(address _user, address _spender)
public
view
returns (uint256)
{
return _allowances[_user][_spender];
}
/**
* @dev Completes transfers by updating the balances on the current block number
* and ensuring the amount does not contain tokens staked for mining
* @param _from address to transfer from
* @param _to address to transfer to
* @param _amount to transfer
*/
function _doTransfer(
address _from,
address _to,
uint256 _amount
) internal {
require(_amount != 0, "Tried to send non-positive amount");
require(_to != address(0), "Receiver is 0 address");
require(
allowedToTrade(_from, _amount),
"Should have sufficient balance to trade"
);
uint256 previousBalance = balanceOf(_from);
updateBalanceAtNow(_from, previousBalance - _amount);
previousBalance = balanceOf(_to);
require(
previousBalance + _amount >= previousBalance,
"Overflow happened"
); // Check for overflow
updateBalanceAtNow(_to, previousBalance + _amount);
emit Transfer(_from, _to, _amount);
}
/**
* @dev Helps swap the old Tellor contract Tokens to the new one
* @param _to is the adress to send minted amount to
* @param _amount is the amount of TRB to send
*/
function _doMint(address _to, uint256 _amount) internal {
require(_amount != 0, "Tried to mint non-positive amount");
require(_to != address(0), "Receiver is 0 address");
uint256 previousBalance = balanceOf(_to);
require(
previousBalance + _amount >= previousBalance,
"Overflow happened"
); // Check for overflow
uint256 previousSupply = uints[_TOTAL_SUPPLY];
require(
previousSupply + _amount >= previousSupply,
"Overflow happened"
);
uints[_TOTAL_SUPPLY] += _amount;
updateBalanceAtNow(_to, previousBalance + _amount);
emit Transfer(address(0), _to, _amount);
}
/**
* @dev Helps burn TRB Tokens
* @param _from is the adress to burn or remove TRB amount
* @param _amount is the amount of TRB to burn
*/
function _doBurn(address _from, uint256 _amount) internal {
if (_amount == 0) return;
uint256 previousBalance = balanceOf(_from);
require(
previousBalance - _amount <= previousBalance,
"Overflow happened"
); // Check for overflow
uint256 previousSupply = uints[_TOTAL_SUPPLY];
require(
previousSupply - _amount <= previousSupply,
"Overflow happened"
);
updateBalanceAtNow(_from, previousBalance - _amount);
uints[_TOTAL_SUPPLY] -= _amount;
}
/**
* @dev Gets balance of owner specified
* @param _user is the owner address used to look up the balance
* @return Returns the balance associated with the passed in _user
*/
function balanceOf(address _user) public view returns (uint256) {
return balanceOfAt(_user, block.number);
}
/**
* @dev Queries the balance of _user at a specific _blockNumber
* @param _user The address from which the balance will be retrieved
* @param _blockNumber The block number when the balance is queried
* @return The balance at _blockNumber specified
*/
function balanceOfAt(address _user, uint256 _blockNumber)
public
view
returns (uint256)
{
TellorStorage.Checkpoint[] storage checkpoints = balances[_user];
if (
checkpoints.length == 0 || checkpoints[0].fromBlock > _blockNumber
) {
return 0;
} else {
if (_blockNumber >= checkpoints[checkpoints.length - 1].fromBlock)
return checkpoints[checkpoints.length - 1].value;
// Binary search of the value in the array
uint256 min = 0;
uint256 max = checkpoints.length - 2;
while (max > min) {
uint256 mid = (max + min + 1) / 2;
if (checkpoints[mid].fromBlock == _blockNumber) {
return checkpoints[mid].value;
} else if (checkpoints[mid].fromBlock < _blockNumber) {
min = mid;
} else {
max = mid - 1;
}
}
return checkpoints[min].value;
}
}
/**
* @dev This function returns whether or not a given user is allowed to trade a given amount
* and removing the staked amount from their balance if they are staked
* @param _user address of user
* @param _amount to check if the user can spend
* @return true if they are allowed to spend the amount being checked
*/
function allowedToTrade(address _user, uint256 _amount)
public
view
returns (bool)
{
if (
stakerDetails[_user].currentStatus != 0 &&
stakerDetails[_user].currentStatus < 5
) {
//Subtracts the stakeAmount from balance if the _user is staked
if (balanceOf(_user) - uints[_STAKE_AMOUNT] >= _amount) {
return true;
}
return false;
}
return (balanceOf(_user) >= _amount);
}
/**
* @dev Updates balance for from and to on the current block number via doTransfer
* @param _value is the new balance
*/
function updateBalanceAtNow(address _user, uint256 _value) public {
Checkpoint[] storage checkpoints = balances[_user];
if (
checkpoints.length == 0 ||
checkpoints[checkpoints.length - 1].fromBlock != block.number
) {
checkpoints.push(
TellorStorage.Checkpoint({
fromBlock: uint128(block.number),
value: uint128(_value)
})
);
} else {
TellorStorage.Checkpoint storage oldCheckPoint =
checkpoints[checkpoints.length - 1];
oldCheckPoint.value = uint128(_value);
}
}
}
// SPDX-License-Identifier: MIT
/**
* This contract holds staking functions, tallyVotes and updateDisputeFee
* Because of space limitations and will be consolidated in future iterations
*/
pragma solidity 0.7.4;
import "./SafeMath.sol";
import "./TellorGetters.sol";
import "./TellorVariables.sol";
import "./Utilities.sol";
contract Extension is TellorGetters {
using SafeMath for uint256;
//emitted upon dispute tally
event DisputeVoteTallied(
uint256 indexed _disputeID,
int256 _result,
address indexed _reportedMiner,
address _reportingParty,
bool _active
);
event StakeWithdrawn(address indexed _sender); //Emits when a staker is block.timestamp no longer staked
event StakeWithdrawRequested(address indexed _sender); //Emits when a staker begins the 7 day withdraw period
event NewStake(address indexed _sender); //Emits upon new staker
/**
* @dev This function allows miners to deposit their stake.
*/
function depositStake() public {
newStake(msg.sender);
updateMinDisputeFee();
}
/**
* @dev This internal function is used the depositStake function to successfully stake miners.
* The function updates their status/state and status start date so they are locked it so they can't withdraw
* and updates the number of stakers in the system.
*/
function newStake(address _staker) internal {
require(
balances[_staker][balances[_staker].length - 1].value >=
uints[_STAKE_AMOUNT],
"Balance is lower than stake amount"
);
//Ensure they can only stake if they are not currently staked or if their stake time frame has ended
//and they are currently locked for withdraw
require(
stakerDetails[_staker].currentStatus == 0 ||
stakerDetails[_staker].currentStatus == 2,
"Miner is in the wrong state"
);
uints[_STAKE_COUNT] += 1;
stakerDetails[_staker] = StakeInfo({
currentStatus: 1, //this resets their stake start date to today
startDate: block.timestamp - (block.timestamp % 86400)
});
emit NewStake(_staker);
}
/*Functions*/
/**
* @dev This function allows stakers to request to withdraw their stake (no longer stake)
* once they lock for withdraw(stakes.currentStatus = 2) they are locked for 7 days before they
* can withdraw the deposit
*/
function requestStakingWithdraw() public {
StakeInfo storage stakes = stakerDetails[msg.sender];
//Require that the miner is staked
require(stakes.currentStatus == 1, "Miner is not staked");
//Change the miner staked to locked to be withdrawStake
stakes.currentStatus = 2;
//Change the startDate to block.timestamp since the lock up period begins block.timestamp
//and the miner can only withdraw 7 days later from block.timestamp(check the withdraw function)
stakes.startDate = block.timestamp - (block.timestamp % 86400);
//Reduce the staker count
uints[_STAKE_COUNT] -= 1;
//Update the minimum dispute fee that is based on the number of stakers
updateMinDisputeFee();
emit StakeWithdrawRequested(msg.sender);
}
/**
* @dev This function allows users to withdraw their stake after a 7 day waiting
* period from request
*/
function withdrawStake() public {
StakeInfo storage stakes = stakerDetails[msg.sender];
//Require the staker has locked for withdraw(currentStatus ==2) and that 7 days have
//passed by since they locked for withdraw
require(
block.timestamp - (block.timestamp % 86400) - stakes.startDate >=
7 days,
"7 days didn't pass"
);
require(
stakes.currentStatus == 2,
"Miner was not locked for withdrawal"
);
stakes.currentStatus = 0;
emit StakeWithdrawn(msg.sender);
}
/**
* @dev tallies the votes and locks the stake disbursement(currentStatus = 4) if the vote passes
* @param _disputeId is the dispute id
*/
function tallyVotes(uint256 _disputeId) public {
Dispute storage disp = disputesById[_disputeId];
//Ensure this has not already been executed/tallied
require(disp.executed == false, "Dispute has been already executed");
require(
block.timestamp >= disp.disputeUintVars[_MIN_EXECUTION_DATE],
"Time for voting haven't elapsed"
);
require(
disp.reportingParty != address(0),
"reporting Party is address 0"
);
int256 _tally = disp.tally;
if (_tally > 0) {
//Set the dispute state to passed/true
disp.disputeVotePassed = true;
}
//If the vote is not a proposed fork
if (disp.isPropFork == false) {
//Ensure the time for voting has elapsed
StakeInfo storage stakes = stakerDetails[disp.reportedMiner];
//If the vote for disputing a value is successful(disp.tally >0) then unstake the reported
// miner and transfer the stakeAmount and dispute fee to the reporting party
if (stakes.currentStatus == 3) {
stakes.currentStatus = 4;
}
}
disp.disputeUintVars[_TALLY_DATE] = block.timestamp;
disp.executed = true;
emit DisputeVoteTallied(
_disputeId,
_tally,
disp.reportedMiner,
disp.reportingParty,
disp.disputeVotePassed
);
}
/**
* @dev This function updates the minimum dispute fee as a function of the amount
* of staked miners
*/
function updateMinDisputeFee() public {
uint256 _stakeAmt = uints[_STAKE_AMOUNT];
uint256 _trgtMiners = uints[_TARGET_MINERS];
uints[_DISPUTE_FEE] = SafeMath.max(
15e18,
(_stakeAmt -
((_stakeAmt *
(SafeMath.min(_trgtMiners, uints[_STAKE_COUNT]) * 1000)) /
_trgtMiners) /
1000)
);
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
/**
* @title Tellor Oracle Storage Library
* @dev Contains all the variables/structs used by Tellor
*/
contract TellorStorage {
//Internal struct for use in proof-of-work submission
struct Details {
uint256 value;
address miner;
}
struct Dispute {
bytes32 hash; //unique hash of dispute: keccak256(_miner,_requestId,_timestamp)
int256 tally; //current tally of votes for - against measure
bool executed; //is the dispute settled
bool disputeVotePassed; //did the vote pass?
bool isPropFork; //true for fork proposal NEW
address reportedMiner; //miner who submitted the 'bad value' will get disputeFee if dispute vote fails
address reportingParty; //miner reporting the 'bad value'-pay disputeFee will get reportedMiner's stake if dispute vote passes
address proposedForkAddress; //new fork address (if fork proposal)
mapping(bytes32 => uint256) disputeUintVars;
//Each of the variables below is saved in the mapping disputeUintVars for each disputeID
//e.g. TellorStorageStruct.DisputeById[disputeID].disputeUintVars[keccak256("requestId")]
//These are the variables saved in this mapping:
// uint keccak256("requestId");//apiID of disputed value
// uint keccak256("timestamp");//timestamp of disputed value
// uint keccak256("value"); //the value being disputed
// uint keccak256("minExecutionDate");//7 days from when dispute initialized
// uint keccak256("numberOfVotes");//the number of parties who have voted on the measure
// uint keccak256("blockNumber");// the blocknumber for which votes will be calculated from
// uint keccak256("minerSlot"); //index in dispute array
// uint keccak256("fee"); //fee paid corresponding to dispute
mapping(address => bool) voted; //mapping of address to whether or not they voted
}
struct StakeInfo {
uint256 currentStatus; //0-not Staked, 1=Staked, 2=LockedForWithdraw 3= OnDispute 4=ReadyForUnlocking 5=Unlocked
uint256 startDate; //stake start date
}
//Internal struct to allow balances to be queried by blocknumber for voting purposes
struct Checkpoint {
uint128 fromBlock; // fromBlock is the block number that the value was generated from
uint128 value; // value is the amount of tokens at a specific block number
}
struct Request {
uint256[] requestTimestamps; //array of all newValueTimestamps requested
mapping(bytes32 => uint256) apiUintVars;
//Each of the variables below is saved in the mapping apiUintVars for each api request
//e.g. requestDetails[_requestId].apiUintVars[keccak256("totalTip")]
//These are the variables saved in this mapping:
// uint keccak256("requestQPosition"); //index in requestQ
// uint keccak256("totalTip");//bonus portion of payout
mapping(uint256 => uint256) minedBlockNum; //[apiId][minedTimestamp]=>block.number
//This the time series of finalValues stored by the contract where uint UNIX timestamp is mapped to value
mapping(uint256 => uint256) finalValues;
mapping(uint256 => bool) inDispute; //checks if API id is in dispute or finalized.
mapping(uint256 => address[5]) minersByValue;
mapping(uint256 => uint256[5]) valuesByTimestamp;
}
uint256[51] requestQ; //uint50 array of the top50 requests by payment amount
uint256[] public newValueTimestamps; //array of all timestamps requested
//Address fields in the Tellor contract are saved the addressVars mapping
//e.g. addressVars[keccak256("tellorContract")] = address
//These are the variables saved in this mapping:
// address keccak256("tellorContract");//Tellor address
// address keccak256("_owner");//Tellor Owner address
// address keccak256("_deity");//Tellor Owner that can do things at will
// address keccak256("pending_owner"); // The proposed new owner
//uint fields in the Tellor contract are saved the uintVars mapping
//e.g. uintVars[keccak256("decimals")] = uint
//These are the variables saved in this mapping:
// keccak256("decimals"); //18 decimal standard ERC20
// keccak256("disputeFee");//cost to dispute a mined value
// keccak256("disputeCount");//totalHistoricalDisputes
// keccak256("total_supply"); //total_supply of the token in circulation
// keccak256("stakeAmount");//stakeAmount for miners (we can cut gas if we just hardcoded it in...or should it be variable?)
// keccak256("stakerCount"); //number of parties currently staked
// keccak256("timeOfLastNewValue"); // time of last challenge solved
// keccak256("difficulty"); // Difficulty of current block
// keccak256("currentTotalTips"); //value of highest api/timestamp PayoutPool
// keccak256("currentRequestId"); //API being mined--updates with the ApiOnQ Id
// keccak256("requestCount"); // total number of requests through the system
// keccak256("slotProgress");//Number of miners who have mined this value so far
// keccak256("miningReward");//Mining Reward in PoWo tokens given to all miners per value
// keccak256("timeTarget"); //The time between blocks (mined Oracle values)
// keccak256("_tblock"); //
// keccak256("runningTips"); // VAriable to track running tips
// keccak256("currentReward"); // The current reward
// keccak256("devShare"); // The amount directed towards th devShare
// keccak256("currentTotalTips"); //
//This is a boolean that tells you if a given challenge has been completed by a given miner
mapping(uint256 => uint256) requestIdByTimestamp; //minedTimestamp to apiId
mapping(uint256 => uint256) requestIdByRequestQIndex; //link from payoutPoolIndex (position in payout pool array) to apiId
mapping(uint256 => Dispute) public disputesById; //disputeId=> Dispute details
mapping(bytes32 => uint256) public requestIdByQueryHash; // api bytes32 gets an id = to count of requests array
mapping(bytes32 => uint256) public disputeIdByDisputeHash; //maps a hash to an ID for each dispute
mapping(bytes32 => mapping(address => bool)) public minersByChallenge;
Details[5] public currentMiners; //This struct is for organizing the five mined values to find the median
mapping(address => StakeInfo) stakerDetails; //mapping from a persons address to their staking info
mapping(uint256 => Request) requestDetails;
mapping(bytes32 => uint256) public uints;
mapping(bytes32 => address) public addresses;
mapping(bytes32 => bytes32) public bytesVars;
//ERC20 storage
mapping(address => Checkpoint[]) public balances;
mapping(address => mapping(address => uint256)) public _allowances;
//Migration storage
mapping(address => bool) public migrated;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
// Helper contract to store hashes of variables
contract TellorVariables {
bytes32 constant _BLOCK_NUMBER =
0x4b4cefd5ced7569ef0d091282b4bca9c52a034c56471a6061afd1bf307a2de7c; //keccak256("_BLOCK_NUMBER");
bytes32 constant _CURRENT_CHALLENGE =
0xd54702836c9d21d0727ffacc3e39f57c92b5ae0f50177e593bfb5ec66e3de280; //keccak256("_CURRENT_CHALLENGE");
bytes32 constant _CURRENT_REQUESTID =
0xf5126bb0ac211fbeeac2c0e89d4c02ac8cadb2da1cfb27b53c6c1f4587b48020; //keccak256("_CURRENT_REQUESTID");
bytes32 constant _CURRENT_REWARD =
0xd415862fd27fb74541e0f6f725b0c0d5b5fa1f22367d9b78ec6f61d97d05d5f8; //keccak256("_CURRENT_REWARD");
bytes32 constant _CURRENT_TOTAL_TIPS =
0x09659d32f99e50ac728058418d38174fe83a137c455ff1847e6fb8e15f78f77a; //keccak256("_CURRENT_TOTAL_TIPS");
bytes32 constant _DEITY =
0x5fc094d10c65bc33cc842217b2eccca0191ff24148319da094e540a559898961; //keccak256("_DEITY");
bytes32 constant _DIFFICULTY =
0xf758978fc1647996a3d9992f611883adc442931dc49488312360acc90601759b; //keccak256("_DIFFICULTY");
bytes32 constant _DISPUTE_COUNT =
0x310199159a20c50879ffb440b45802138b5b162ec9426720e9dd3ee8bbcdb9d7; //keccak256("_DISPUTE_COUNT");
bytes32 constant _DISPUTE_FEE =
0x675d2171f68d6f5545d54fb9b1fb61a0e6897e6188ca1cd664e7c9530d91ecfc; //keccak256("_DISPUTE_FEE");
bytes32 constant _DISPUTE_ROUNDS =
0x6ab2b18aafe78fd59c6a4092015bddd9fcacb8170f72b299074f74d76a91a923; //keccak256("_DISPUTE_ROUNDS");
bytes32 constant _EXTENSION =
0x2b2a1c876f73e67ebc4f1b08d10d54d62d62216382e0f4fd16c29155818207a4; //keccak256("_EXTENSION");
bytes32 constant _FEE =
0x1da95f11543c9b03927178e07951795dfc95c7501a9d1cf00e13414ca33bc409; //keccak256("FEE");
bytes32 constant _MIGRATOR =
0xc6b005d45c4c789dfe9e2895b51df4336782c5ff6bd59a5c5c9513955aa06307; //keccak256("_MIGRATOR");
bytes32 constant _MIN_EXECUTION_DATE =
0x46f7d53798d31923f6952572c6a19ad2d1a8238d26649c2f3493a6d69e425d28; //keccak256("_MIN_EXECUTION_DATE");
bytes32 constant _MINER_SLOT =
0x6de96ee4d33a0617f40a846309c8759048857f51b9d59a12d3c3786d4778883d; //keccak256("_MINER_SLOT");
bytes32 constant _NUM_OF_VOTES =
0x1da378694063870452ce03b189f48e04c1aa026348e74e6c86e10738514ad2c4; //keccak256("_NUM_OF_VOTES");
bytes32 constant _OLD_TELLOR =
0x56e0987db9eaec01ed9e0af003a0fd5c062371f9d23722eb4a3ebc74f16ea371; //keccak256("_OLD_TELLOR");
bytes32 constant _ORIGINAL_ID =
0xed92b4c1e0a9e559a31171d487ecbec963526662038ecfa3a71160bd62fb8733; //keccak256("_ORIGINAL_ID");
bytes32 constant _OWNER =
0x7a39905194de50bde334d18b76bbb36dddd11641d4d50b470cb837cf3bae5def; //keccak256("_OWNER");
bytes32 constant _PAID =
0x29169706298d2b6df50a532e958b56426de1465348b93650fca42d456eaec5fc; //keccak256("_PAID");
bytes32 constant _PENDING_OWNER =
0x7ec081f029b8ac7e2321f6ae8c6a6a517fda8fcbf63cabd63dfffaeaafa56cc0; //keccak256("_PENDING_OWNER");
bytes32 constant _REQUEST_COUNT =
0x3f8b5616fa9e7f2ce4a868fde15c58b92e77bc1acd6769bf1567629a3dc4c865; //keccak256("_REQUEST_COUNT");
bytes32 constant _REQUEST_ID =
0x9f47a2659c3d32b749ae717d975e7962959890862423c4318cf86e4ec220291f; //keccak256("_REQUEST_ID");
bytes32 constant _REQUEST_Q_POSITION =
0xf68d680ab3160f1aa5d9c3a1383c49e3e60bf3c0c031245cbb036f5ce99afaa1; //keccak256("_REQUEST_Q_POSITION");
bytes32 constant _SLOT_PROGRESS =
0xdfbec46864bc123768f0d134913175d9577a55bb71b9b2595fda21e21f36b082; //keccak256("_SLOT_PROGRESS");
bytes32 constant _STAKE_AMOUNT =
0x5d9fadfc729fd027e395e5157ef1b53ef9fa4a8f053043c5f159307543e7cc97; //keccak256("_STAKE_AMOUNT");
bytes32 constant _STAKE_COUNT =
0x10c168823622203e4057b65015ff4d95b4c650b308918e8c92dc32ab5a0a034b; //keccak256("_STAKE_COUNT");
bytes32 constant _T_BLOCK =
0xf3b93531fa65b3a18680d9ea49df06d96fbd883c4889dc7db866f8b131602dfb; //keccak256("_T_BLOCK");
bytes32 constant _TALLY_DATE =
0xf9e1ae10923bfc79f52e309baf8c7699edb821f91ef5b5bd07be29545917b3a6; //keccak256("_TALLY_DATE");
bytes32 constant _TARGET_MINERS =
0x0b8561044b4253c8df1d9ad9f9ce2e0f78e4bd42b2ed8dd2e909e85f750f3bc1; //keccak256("_TARGET_MINERS");
bytes32 constant _TELLOR_CONTRACT =
0x0f1293c916694ac6af4daa2f866f0448d0c2ce8847074a7896d397c961914a08; //keccak256("_TELLOR_CONTRACT");
bytes32 constant _TELLOR_GETTERS =
0xabd9bea65759494fe86471c8386762f989e1f2e778949e94efa4a9d1c4b3545a; //keccak256("_TELLOR_GETTERS");
bytes32 constant _TIME_OF_LAST_NEW_VALUE =
0x2c8b528fbaf48aaf13162a5a0519a7ad5a612da8ff8783465c17e076660a59f1; //keccak256("_TIME_OF_LAST_NEW_VALUE");
bytes32 constant _TIME_TARGET =
0xd4f87b8d0f3d3b7e665df74631f6100b2695daa0e30e40eeac02172e15a999e1; //keccak256("_TIME_TARGET");
bytes32 constant _TIMESTAMP =
0x2f9328a9c75282bec25bb04befad06926366736e0030c985108445fa728335e5; //keccak256("_TIMESTAMP");
bytes32 constant _TOTAL_SUPPLY =
0xe6148e7230ca038d456350e69a91b66968b222bfac9ebfbea6ff0a1fb7380160; //keccak256("_TOTAL_SUPPLY");
bytes32 constant _TOTAL_TIP =
0x1590276b7f31dd8e2a06f9a92867333eeb3eddbc91e73b9833e3e55d8e34f77d; //keccak256("_TOTAL_TIP");
bytes32 constant _VALUE =
0x9147231ab14efb72c38117f68521ddef8de64f092c18c69dbfb602ffc4de7f47; //keccak256("_VALUE");
bytes32 constant _EIP_SLOT =
0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
} | * @title Tellor Getters @dev Oracle contract with all tellor getter functions/ | contract TellorGetters is TellorStorage, TellorVariables, Utilities {
using SafeMath for uint256;
function didMine(bytes32 _challenge, address _miner)
public
view
returns (bool)
pragma solidity 0.7.4;
{
return minersByChallenge[_challenge][_miner];
}
function didVote(uint256 _disputeId, address _address)
external
view
returns (bool)
{
return disputesById[_disputeId].voted[_address];
}
function getAddressVars(bytes32 _data) external view returns (address) {
return addresses[_data];
}
function getAllDisputeVars(uint256 _disputeId)
public
view
returns (
bytes32,
bool,
bool,
bool,
address,
address,
address,
uint256[9] memory,
int256
)
{
Dispute storage disp = disputesById[_disputeId];
return (
disp.hash,
disp.executed,
disp.disputeVotePassed,
disp.isPropFork,
disp.reportedMiner,
disp.reportingParty,
disp.proposedForkAddress,
[
disp.disputeUintVars[_REQUEST_ID],
disp.disputeUintVars[_TIMESTAMP],
disp.disputeUintVars[_VALUE],
disp.disputeUintVars[_MIN_EXECUTION_DATE],
disp.disputeUintVars[_NUM_OF_VOTES],
disp.disputeUintVars[_BLOCK_NUMBER],
disp.disputeUintVars[_MINER_SLOT],
disp.disputeUintVars[keccak256("quorum")],
disp.disputeUintVars[_FEE]
],
disp.tally
);
}
function getDisputeIdByDisputeHash(bytes32 _hash)
external
view
returns (uint256)
{
return disputeIdByDisputeHash[_hash];
}
function getDisputeUintVars(uint256 _disputeId, bytes32 _data)
external
view
returns (uint256)
{
return disputesById[_disputeId].disputeUintVars[_data];
}
function getLastNewValue() external view returns (uint256, bool) {
return (
retrieveData(
requestIdByTimestamp[uints[_TIME_OF_LAST_NEW_VALUE]],
uints[_TIME_OF_LAST_NEW_VALUE]
),
true
);
}
function getLastNewValueById(uint256 _requestId)
external
view
returns (uint256, bool)
{
Request storage _request = requestDetails[_requestId];
if (_request.requestTimestamps.length != 0) {
return (
retrieveData(
_requestId,
_request.requestTimestamps[
_request.requestTimestamps.length - 1
]
),
true
);
return (0, false);
}
}
function getLastNewValueById(uint256 _requestId)
external
view
returns (uint256, bool)
{
Request storage _request = requestDetails[_requestId];
if (_request.requestTimestamps.length != 0) {
return (
retrieveData(
_requestId,
_request.requestTimestamps[
_request.requestTimestamps.length - 1
]
),
true
);
return (0, false);
}
}
} else {
function getMinedBlockNum(uint256 _requestId, uint256 _timestamp)
external
view
returns (uint256)
{
return requestDetails[_requestId].minedBlockNum[_timestamp];
}
function getMinersByRequestIdAndTimestamp(
uint256 _requestId,
uint256 _timestamp
) external view returns (address[5] memory) {
return requestDetails[_requestId].minersByValue[_timestamp];
}
function getNewValueCountbyRequestId(uint256 _requestId)
external
view
returns (uint256)
{
return requestDetails[_requestId].requestTimestamps.length;
}
function getRequestIdByRequestQIndex(uint256 _index)
external
view
returns (uint256)
{
require(_index <= 50, "RequestQ index is above 50");
return requestIdByRequestQIndex[_index];
}
function getRequestIdByTimestamp(uint256 _timestamp)
external
view
returns (uint256)
{
return requestIdByTimestamp[_timestamp];
}
function getRequestQ() public view returns (uint256[51] memory) {
return requestQ;
}
function getRequestUintVars(uint256 _requestId, bytes32 _data)
external
view
returns (uint256)
{
return requestDetails[_requestId].apiUintVars[_data];
}
function getRequestVars(uint256 _requestId)
external
view
returns (uint256, uint256)
{
Request storage _request = requestDetails[_requestId];
return (
_request.apiUintVars[_REQUEST_Q_POSITION],
_request.apiUintVars[_TOTAL_TIP]
);
}
function getStakerInfo(address _staker)
external
view
returns (uint256, uint256)
{
return (
stakerDetails[_staker].currentStatus,
stakerDetails[_staker].startDate
);
}
function getSubmissionsByTimestamp(uint256 _requestId, uint256 _timestamp)
external
view
returns (uint256[5] memory)
{
return requestDetails[_requestId].valuesByTimestamp[_timestamp];
}
function getTimestampbyRequestIDandIndex(uint256 _requestID, uint256 _index)
external
view
returns (uint256)
{
return requestDetails[_requestID].requestTimestamps[_index];
}
function getUintVar(bytes32 _data) public view returns (uint256) {
return uints[_data];
}
function isInDispute(uint256 _requestId, uint256 _timestamp)
external
view
returns (bool)
{
return requestDetails[_requestId].inDispute[_timestamp];
}
function retrieveData(uint256 _requestId, uint256 _timestamp)
public
view
returns (uint256)
{
return requestDetails[_requestId].finalValues[_timestamp];
}
function totalSupply() external view returns (uint256) {
return uints[_TOTAL_SUPPLY];
}
function name() external pure returns (string memory) {
return "Tellor Tributes";
}
function symbol() external pure returns (string memory) {
return "TRB";
}
function decimals() external pure returns (uint8) {
return 18;
}
function getNewCurrentVariables()
external
view
returns (
bytes32 _challenge,
uint256[5] memory _requestIds,
uint256 _diff,
uint256 _tip
)
{
for (uint256 i = 0; i < 5; i++) {
_requestIds[i] = currentMiners[i].value;
}
return (
bytesVars[_CURRENT_CHALLENGE],
_requestIds,
uints[_DIFFICULTY],
uints[_CURRENT_TOTAL_TIPS]
);
}
function getNewCurrentVariables()
external
view
returns (
bytes32 _challenge,
uint256[5] memory _requestIds,
uint256 _diff,
uint256 _tip
)
{
for (uint256 i = 0; i < 5; i++) {
_requestIds[i] = currentMiners[i].value;
}
return (
bytesVars[_CURRENT_CHALLENGE],
_requestIds,
uints[_DIFFICULTY],
uints[_CURRENT_TOTAL_TIPS]
);
}
function getNewVariablesOnDeck()
external
view
returns (uint256[5] memory idsOnDeck, uint256[5] memory tipsOnDeck)
{
idsOnDeck = getTopRequestIDs();
for (uint256 i = 0; i < 5; i++) {
tipsOnDeck[i] = requestDetails[idsOnDeck[i]].apiUintVars[
_TOTAL_TIP
];
}
}
function getNewVariablesOnDeck()
external
view
returns (uint256[5] memory idsOnDeck, uint256[5] memory tipsOnDeck)
{
idsOnDeck = getTopRequestIDs();
for (uint256 i = 0; i < 5; i++) {
tipsOnDeck[i] = requestDetails[idsOnDeck[i]].apiUintVars[
_TOTAL_TIP
];
}
}
function getTopRequestIDs()
public
view
returns (uint256[5] memory _requestIds)
{
uint256[5] memory _max;
uint256[5] memory _index;
(_max, _index) = getMax5(requestQ);
for (uint256 i = 0; i < 5; i++) {
if (_max[i] != 0) {
_requestIds[i] = requestIdByRequestQIndex[_index[i]];
_requestIds[i] = currentMiners[4 - i].value;
}
}
}
function getTopRequestIDs()
public
view
returns (uint256[5] memory _requestIds)
{
uint256[5] memory _max;
uint256[5] memory _index;
(_max, _index) = getMax5(requestQ);
for (uint256 i = 0; i < 5; i++) {
if (_max[i] != 0) {
_requestIds[i] = requestIdByRequestQIndex[_index[i]];
_requestIds[i] = currentMiners[4 - i].value;
}
}
}
function getTopRequestIDs()
public
view
returns (uint256[5] memory _requestIds)
{
uint256[5] memory _max;
uint256[5] memory _index;
(_max, _index) = getMax5(requestQ);
for (uint256 i = 0; i < 5; i++) {
if (_max[i] != 0) {
_requestIds[i] = requestIdByRequestQIndex[_index[i]];
_requestIds[i] = currentMiners[4 - i].value;
}
}
}
} else {
}
| 6,847,352 | [
1,
21009,
280,
968,
5432,
225,
28544,
6835,
598,
777,
9276,
280,
7060,
4186,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
29860,
280,
967,
5432,
353,
29860,
280,
3245,
16,
29860,
280,
6158,
16,
26703,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
203,
565,
445,
5061,
49,
558,
12,
3890,
1578,
389,
25092,
16,
1758,
389,
1154,
264,
13,
203,
3639,
1071,
203,
3639,
1476,
203,
3639,
1135,
261,
6430,
13,
203,
683,
9454,
18035,
560,
374,
18,
27,
18,
24,
31,
203,
565,
288,
203,
3639,
327,
1131,
414,
858,
18359,
63,
67,
25092,
6362,
67,
1154,
264,
15533,
203,
565,
289,
203,
203,
565,
445,
5061,
19338,
12,
11890,
5034,
389,
2251,
2507,
548,
16,
1758,
389,
2867,
13,
203,
3639,
3903,
203,
3639,
1476,
203,
3639,
1135,
261,
6430,
13,
203,
565,
288,
203,
3639,
327,
1015,
458,
281,
5132,
63,
67,
2251,
2507,
548,
8009,
90,
16474,
63,
67,
2867,
15533,
203,
565,
289,
203,
203,
565,
445,
14808,
5555,
12,
3890,
1578,
389,
892,
13,
3903,
1476,
1135,
261,
2867,
13,
288,
203,
3639,
327,
6138,
63,
67,
892,
15533,
203,
565,
289,
203,
203,
565,
445,
5514,
1669,
2507,
5555,
12,
11890,
5034,
389,
2251,
2507,
548,
13,
203,
3639,
1071,
203,
3639,
1476,
203,
3639,
1135,
261,
203,
5411,
1731,
1578,
16,
203,
5411,
1426,
16,
203,
5411,
1426,
16,
203,
5411,
1426,
16,
203,
5411,
1758,
16,
203,
5411,
1758,
16,
203,
5411,
1758,
16,
203,
5411,
2254,
5034,
63,
29,
65,
3778,
16,
203,
5411,
509,
5034,
203,
3639,
262,
203,
565,
288,
203,
3639,
3035,
2507,
2502,
16232,
273,
1015,
2
]
|
./full_match/5/0xe368F3bd2F8513C908baF57669C3E7F569BE63cc/sources/BankNegara.sol | i changed it to this
| require(msg.sender == admin); | 1,951,602 | [
1,
77,
3550,
518,
358,
333,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
3639,
2583,
12,
3576,
18,
15330,
422,
3981,
1769,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// Copyright (C) 2020 Zerion Inc. <https://zerion.io>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.6.5;
pragma experimental ABIEncoderV2;
interface ProtocolAdapter {
function ADAPTERTYPE67() external pure returns (string memory); //inject NONSTANDARD NAMING
function TOKENTYPE890() external pure returns (string memory); //inject NONSTANDARD NAMING
function GETBALANCE609(address token, address account) external view returns (uint256); //inject NONSTANDARD NAMING
}
abstract contract DyDxAdapter {
address internal constant solo634 = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e; //inject NONSTANDARD NAMING
address internal constant weth612 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; //inject NONSTANDARD NAMING
address internal constant sai129 = 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359; //inject NONSTANDARD NAMING
address internal constant usdc544 = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; //inject NONSTANDARD NAMING
address internal constant dai140 = 0x6B175474E89094C44Da98b954EedeAC495271d0F; //inject NONSTANDARD NAMING
function GETMARKETID905(address token) internal pure returns (uint256) { //inject NONSTANDARD NAMING
if (token == weth612) {
return uint256(0);
} else if (token == sai129) {
return uint256(1);
} else if (token == usdc544) {
return uint256(2);
} else if (token == dai140) {
return uint256(3);
} else {
return uint256(-1);
}
}
}
struct Info {
address owner; // The address that owns the account
uint256 number; // A nonce that allows a single address to control many accounts
}
struct Wei {
bool sign; // true if positive
uint256 value;
}
interface SoloMargin {
function GETACCOUNTWEI374(Info calldata, uint256) external view returns (Wei memory); //inject NONSTANDARD NAMING
}
contract DyDxAssetAdapter is ProtocolAdapter, DyDxAdapter {
string public constant override adaptertype368 = "Asset"; //inject NONSTANDARD NAMING
string public constant override tokentype164 = "ERC20"; //inject NONSTANDARD NAMING
function GETBALANCE609(address token, address account) external view override returns (uint256) { //inject NONSTANDARD NAMING
Wei memory accountWei = SoloMargin(solo634).GETACCOUNTWEI374(Info(account, 0), GETMARKETID905(token));
return accountWei.sign ? accountWei.value : 0;
}
} | inject NONSTANDARD NAMING
| address internal constant weth612 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; | 12,865,783 | [
1,
22170,
18708,
882,
18264,
423,
2192,
1360,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
1758,
2713,
5381,
341,
546,
26,
2138,
273,
374,
14626,
3103,
7598,
37,
5520,
70,
3787,
23,
8090,
28,
40,
20,
37,
20,
73,
25,
39,
24,
42,
5324,
73,
1880,
29,
6840,
23,
39,
27,
4313,
39,
71,
22,
31,
202,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/42/0xFDEda95AFE059fc476608b903569Cca9ac9De0B6/sources/gist-f856530b20943e92ed6cc69c1285cdfe/TSLAStockDataKovan.sol | * Make initial request/ | function requestTSLAPrice() public {
Chainlink.Request memory req = buildChainlinkRequest(jobId, address(this), this.fulfillEthereumPrice.selector);
req.add("function", "GLOBAL_QUOTE");
req.add("symbol", "TSLA");
string[] memory copyPath = new string[](2);
copyPath[0] = "Global Quote";
copyPath[1] = "05. price";
req.addStringArray("copyPath", copyPath);
req.addInt("times", 100000000);
sendChainlinkRequestTo(oracle, req, fee);
}
| 9,587,337 | [
1,
6464,
2172,
590,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
590,
56,
4559,
2203,
3057,
1435,
1071,
288,
203,
377,
202,
3893,
1232,
18,
691,
3778,
1111,
273,
1361,
3893,
1232,
691,
12,
4688,
548,
16,
1758,
12,
2211,
3631,
333,
18,
2706,
5935,
41,
18664,
379,
5147,
18,
9663,
1769,
203,
377,
202,
3658,
18,
1289,
2932,
915,
3113,
315,
20402,
67,
18980,
8863,
203,
377,
202,
3658,
18,
1289,
2932,
7175,
3113,
315,
8047,
2534,
8863,
203,
377,
202,
1080,
8526,
3778,
1610,
743,
273,
394,
533,
8526,
12,
22,
1769,
203,
3639,
1610,
743,
63,
20,
65,
273,
315,
5160,
21695,
14432,
203,
3639,
1610,
743,
63,
21,
65,
273,
315,
6260,
18,
6205,
14432,
203,
3639,
1111,
18,
1289,
28547,
2932,
3530,
743,
3113,
1610,
743,
1769,
203,
3639,
1111,
18,
1289,
1702,
2932,
8293,
3113,
2130,
9449,
1769,
203,
377,
202,
4661,
3893,
1232,
691,
774,
12,
280,
16066,
16,
1111,
16,
14036,
1769,
203,
565,
289,
203,
377,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0x9422221B4941FcFEFf48f84143Da9602F6d24aa6/sources/contracts/ShillingTokenClaimsV2.sol | Error thrown with attempting to claim but claiming is not allowed
| error ClaimNotAllowed(); | 2,900,558 | [
1,
668,
6718,
598,
15600,
358,
7516,
1496,
7516,
310,
353,
486,
2935,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
555,
18381,
19354,
5621,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/43113/0x8519BdefCc30989dB2C8777a9Aef99924e4bf427/sources/src/GhostmarketERC721_flat.sol | struct for royalties fees | contract GhostMarketERC721 is Initializable, ERC721PresetMinterPauserAutoIdUpgradeableCustom, ReentrancyGuardUpgradeable, OwnableUpgradeable, ERC165StorageUpgradeable {
struct Royalty {
address payable recipient;
uint256 value;
}
event MintFeesWithdrawn(address feeWithdrawer, uint256 withdrawAmount);
event MintFeesUpdated(address feeChanger, uint256 newValue);
event Minted(address toAddress, uint256 tokenId, string externalURI);
mapping(uint256 => Royalty[]) internal _royalties;
mapping(uint256 => string) internal _lockedContent;
mapping(uint256 => uint256) internal _lockedContentViewTracker;
mapping(uint256 => string) internal _metadataJson;
event LockedContentViewed(address msgSender, uint256 tokenId, string lockedContent);
uint256 internal _payedMintFeesBalance;
uint256 internal _ghostmarketMintFees;
bytes4 constant _INTERFACE_ID_ERC721_GHOSTMARKET = bytes4(keccak256("_INTERFACE_ID_ERC721_GHOSTMARKET"));
bytes4 constant _GHOSTMARKET_NFT_ROYALTIES = bytes4(keccak256("_GHOSTMARKET_NFT_ROYALTIES"));
function initialize(string memory name, string memory symbol, string memory uri)
public
override
initializer
{
__Context_init_unchained();
__ERC165_init_unchained();
__AccessControl_init_unchained();
__AccessControlEnumerable_init_unchained();
__ERC721Enumerable_init_unchained();
__ERC721Burnable_init_unchained();
__Pausable_init_unchained();
__ERC721Pausable_init_unchained();
__ERC721URIStorage_init_unchained();
__ERC721_init_unchained(name, symbol);
__ERC721PresetMinterPauserAutoId_init_unchained(uri);
__Ownable_init_unchained();
_registerInterface(_INTERFACE_ID_ERC721_GHOSTMARKET);
_registerInterface(_GHOSTMARKET_NFT_ROYALTIES);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721PresetMinterPauserAutoIdUpgradeableCustom, ERC165StorageUpgradeable) returns (bool) {
return super.supportsInterface(interfaceId);
}
function _saveRoyalties(uint256 tokenId, Royalty[] memory royalties)
internal
{
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
for (uint256 i = 0; i < royalties.length; i++) {
require(royalties[i].recipient != address(0x0), "Recipient should be present");
require(royalties[i].value > 0, "Royalties value should be positive");
require(royalties[i].value <= 5000, "Royalties value should not be more than 50%");
_royalties[tokenId].push(royalties[i]);
}
}
function _saveRoyalties(uint256 tokenId, Royalty[] memory royalties)
internal
{
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
for (uint256 i = 0; i < royalties.length; i++) {
require(royalties[i].recipient != address(0x0), "Recipient should be present");
require(royalties[i].value > 0, "Royalties value should be positive");
require(royalties[i].value <= 5000, "Royalties value should not be more than 50%");
_royalties[tokenId].push(royalties[i]);
}
}
function _setMetadataJson(uint256 tokenId, string memory metadataJson)
internal
{
_metadataJson[tokenId] = metadataJson;
}
function _setLockedContent(uint256 tokenId, string memory content)
internal
{
_lockedContent[tokenId] = content;
}
function _checkMintFees()
internal
{
if (_ghostmarketMintFees > 0) {
require(msg.value == _ghostmarketMintFees, "Wrong fees value sent to GhostMarket for mint fees");
}
if (msg.value > 0) {
_payedMintFeesBalance += msg.value;
}
}
function _checkMintFees()
internal
{
if (_ghostmarketMintFees > 0) {
require(msg.value == _ghostmarketMintFees, "Wrong fees value sent to GhostMarket for mint fees");
}
if (msg.value > 0) {
_payedMintFeesBalance += msg.value;
}
}
function _checkMintFees()
internal
{
if (_ghostmarketMintFees > 0) {
require(msg.value == _ghostmarketMintFees, "Wrong fees value sent to GhostMarket for mint fees");
}
if (msg.value > 0) {
_payedMintFeesBalance += msg.value;
}
}
function _incrementCurrentLockedContentViewTracker(uint256 tokenId)
internal
{
_lockedContentViewTracker[tokenId] = _lockedContentViewTracker[tokenId] + 1;
}
function mintGhost(address to, Royalty[] memory royalties, string memory externalURI, string memory metadata, string memory lockedcontent)
external
payable
nonReentrant
{
require(to != address(0x0), "to can't be empty");
require(keccak256(abi.encodePacked(externalURI)) != keccak256(abi.encodePacked("")), "externalURI can't be empty");
mint(to);
uint256 tokenId = getLastTokenID();
if (royalties.length > 0) {
_saveRoyalties(tokenId, royalties);
}
if (keccak256(abi.encodePacked(metadata)) != keccak256(abi.encodePacked(""))) {
_setMetadataJson(tokenId, metadata);
}
if (keccak256(abi.encodePacked(lockedcontent)) != keccak256(abi.encodePacked(""))) {
_setLockedContent(tokenId, lockedcontent);
}
_checkMintFees();
emit Minted(to, tokenId, externalURI);
}
function mintGhost(address to, Royalty[] memory royalties, string memory externalURI, string memory metadata, string memory lockedcontent)
external
payable
nonReentrant
{
require(to != address(0x0), "to can't be empty");
require(keccak256(abi.encodePacked(externalURI)) != keccak256(abi.encodePacked("")), "externalURI can't be empty");
mint(to);
uint256 tokenId = getLastTokenID();
if (royalties.length > 0) {
_saveRoyalties(tokenId, royalties);
}
if (keccak256(abi.encodePacked(metadata)) != keccak256(abi.encodePacked(""))) {
_setMetadataJson(tokenId, metadata);
}
if (keccak256(abi.encodePacked(lockedcontent)) != keccak256(abi.encodePacked(""))) {
_setLockedContent(tokenId, lockedcontent);
}
_checkMintFees();
emit Minted(to, tokenId, externalURI);
}
function mintGhost(address to, Royalty[] memory royalties, string memory externalURI, string memory metadata, string memory lockedcontent)
external
payable
nonReentrant
{
require(to != address(0x0), "to can't be empty");
require(keccak256(abi.encodePacked(externalURI)) != keccak256(abi.encodePacked("")), "externalURI can't be empty");
mint(to);
uint256 tokenId = getLastTokenID();
if (royalties.length > 0) {
_saveRoyalties(tokenId, royalties);
}
if (keccak256(abi.encodePacked(metadata)) != keccak256(abi.encodePacked(""))) {
_setMetadataJson(tokenId, metadata);
}
if (keccak256(abi.encodePacked(lockedcontent)) != keccak256(abi.encodePacked(""))) {
_setLockedContent(tokenId, lockedcontent);
}
_checkMintFees();
emit Minted(to, tokenId, externalURI);
}
function mintGhost(address to, Royalty[] memory royalties, string memory externalURI, string memory metadata, string memory lockedcontent)
external
payable
nonReentrant
{
require(to != address(0x0), "to can't be empty");
require(keccak256(abi.encodePacked(externalURI)) != keccak256(abi.encodePacked("")), "externalURI can't be empty");
mint(to);
uint256 tokenId = getLastTokenID();
if (royalties.length > 0) {
_saveRoyalties(tokenId, royalties);
}
if (keccak256(abi.encodePacked(metadata)) != keccak256(abi.encodePacked(""))) {
_setMetadataJson(tokenId, metadata);
}
if (keccak256(abi.encodePacked(lockedcontent)) != keccak256(abi.encodePacked(""))) {
_setLockedContent(tokenId, lockedcontent);
}
_checkMintFees();
emit Minted(to, tokenId, externalURI);
}
function withdraw(uint256 withdrawAmount)
external
onlyOwner
{
require(withdrawAmount > 0 && withdrawAmount <= _payedMintFeesBalance, "Withdraw amount should be greater then 0 and less then contract balance");
_payedMintFeesBalance -= withdrawAmount;
require(success, "Transfer failed.");
emit MintFeesWithdrawn(msg.sender, withdrawAmount);
}
(bool success, ) = msg.sender.call{value: withdrawAmount}("");
function burnBatch(uint256[] memory tokensId)
external
{
for (uint256 i = 0; i < tokensId.length; i++) {
burn(tokensId[i]);
}
}
function burnBatch(uint256[] memory tokensId)
external
{
for (uint256 i = 0; i < tokensId.length; i++) {
burn(tokensId[i]);
}
}
function setGhostmarketMintFee(uint256 gmmf)
external
{
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Caller must have admin role to set mint fees");
_ghostmarketMintFees = gmmf;
emit MintFeesUpdated(msg.sender, _ghostmarketMintFees);
}
function getGhostmarketMintFees()
external
view
returns (uint256)
{
return _ghostmarketMintFees;
}
function getLockedContent(uint256 tokenId)
external
{
require(ownerOf(tokenId) == msg.sender, "Caller must be the owner of the NFT");
_incrementCurrentLockedContentViewTracker(tokenId);
emit LockedContentViewed(msg.sender, tokenId, _lockedContent[tokenId]);
}
function getCurrentLockedContentViewTracker(uint256 tokenId)
external
view
returns (uint256)
{
return _lockedContentViewTracker[tokenId];
}
function getMetadataJson(uint256 tokenId)
external
view
returns (string memory)
{
return _metadataJson[tokenId];
}
function getRoyalties(uint256 tokenId)
external
view
returns (Royalty[] memory)
{
return _royalties[tokenId];
}
function getRoyaltiesRecipients(uint256 tokenId)
external
view
returns (address payable[] memory)
{
Royalty[] memory royalties = _royalties[tokenId];
address payable[] memory result = new address payable[](royalties.length);
for (uint256 i = 0; i < royalties.length; i++) {
result[i] = royalties[i].recipient;
}
return result;
}
function getRoyaltiesRecipients(uint256 tokenId)
external
view
returns (address payable[] memory)
{
Royalty[] memory royalties = _royalties[tokenId];
address payable[] memory result = new address payable[](royalties.length);
for (uint256 i = 0; i < royalties.length; i++) {
result[i] = royalties[i].recipient;
}
return result;
}
function getRoyaltiesBps(uint256 tokenId)
external
view
returns (uint256[] memory)
{
Royalty[] memory royalties = _royalties[tokenId];
uint256[] memory result = new uint256[](royalties.length);
for (uint256 i = 0; i < royalties.length; i++) {
result[i] = royalties[i].value;
}
return result;
}
uint256[50] private __gap;
function getRoyaltiesBps(uint256 tokenId)
external
view
returns (uint256[] memory)
{
Royalty[] memory royalties = _royalties[tokenId];
uint256[] memory result = new uint256[](royalties.length);
for (uint256 i = 0; i < royalties.length; i++) {
result[i] = royalties[i].value;
}
return result;
}
uint256[50] private __gap;
}
| 7,183,442 | [
1,
1697,
364,
721,
93,
2390,
606,
1656,
281,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
611,
2564,
3882,
278,
654,
39,
27,
5340,
353,
10188,
6934,
16,
4232,
39,
27,
5340,
18385,
49,
2761,
16507,
1355,
4965,
548,
10784,
429,
3802,
16,
868,
8230,
12514,
16709,
10784,
429,
16,
14223,
6914,
10784,
429,
16,
4232,
39,
28275,
3245,
10784,
429,
288,
203,
203,
203,
202,
1697,
534,
13372,
15006,
288,
203,
202,
202,
2867,
8843,
429,
8027,
31,
203,
202,
202,
11890,
5034,
460,
31,
203,
202,
97,
203,
203,
203,
203,
203,
203,
282,
202,
2575,
490,
474,
2954,
281,
1190,
9446,
82,
12,
2867,
14036,
1190,
9446,
264,
16,
2254,
5034,
598,
9446,
6275,
1769,
203,
202,
2575,
490,
474,
2954,
281,
7381,
12,
2867,
14036,
782,
11455,
16,
2254,
5034,
6129,
1769,
203,
202,
2575,
490,
474,
329,
12,
2867,
358,
1887,
16,
2254,
5034,
1147,
548,
16,
533,
3903,
3098,
1769,
203,
203,
203,
203,
202,
203,
203,
202,
6770,
12,
11890,
5034,
516,
534,
13372,
15006,
63,
5717,
2713,
389,
3800,
2390,
606,
31,
203,
202,
6770,
12,
11890,
5034,
516,
533,
13,
2713,
389,
15091,
1350,
31,
203,
202,
6770,
12,
11890,
5034,
516,
2254,
5034,
13,
2713,
389,
15091,
1350,
1767,
8135,
31,
203,
202,
6770,
12,
11890,
5034,
516,
533,
13,
2713,
389,
4165,
3185,
31,
203,
202,
2575,
3488,
329,
1350,
1767,
329,
12,
2867,
1234,
12021,
16,
2254,
5034,
1147,
548,
16,
533,
8586,
1350,
1769,
203,
202,
11890,
5034,
2713,
389,
10239,
329,
49,
474,
2954,
281,
13937,
31,
203,
202,
11890,
5034,
2713,
389,
75,
2564,
2
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
/**
* @title Structs used by SAV Doc contracts
*/
contract SaveDocStruct
{
/**
* @dev Different types of document
*/
enum TypeDoc
{
Original,
CopyShared,
CopyCertified,
CopyPendingTransfer
}
/**
* @dev Document struct
*/
struct Document
{
uint256 tokenID; // ID of token
uint256 fileSize; // size of document
string filename; // name of document
string fileMimeType; // mime type of document
uint256 dateAdd; // date the document was added
string filePath; // folder of document
address[] certifying; // list of certifying
string tokenURI; // URI document
string passwordEncrypted; // encrypted password of document
TypeDoc typeNft; // type of document (see TypeDoc struct)
}
/**
* @dev Certification request struct
*/
struct CertificationRequest
{
address applicant;
uint256 tokenID;
bool exist;
}
/**
* @dev User struct
*/
struct User
{
string name; // username
string publicKey; // public key
bool isAuthority; // true if user is an authority
bool exist; // true if user is registered
}
}
| mime type of document
| string fileMimeType; | 1,814,323 | [
1,
11757,
618,
434,
1668,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
4202,
533,
585,
16821,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0x84BA914B1a2411d31A365C17D55f8C02a8ca31f4/sources/erc1155delta/contracts/ERC1155Delta.sol | * @dev Destroys tokens of token types in `ids` from `from` Emits a {TransferBatch} event. Requirements: - `from` cannot be the zero address. - `from` must have the token of token types in `ids`./ | function _burnBatch(
address from,
uint256[] memory ids
) internal virtual {
if(from == address(0)){
revert BurnFromZeroAddress();
}
address operator = _msgSender();
uint256[] memory amounts = new uint256[](ids.length);
_beforeTokenTransfer(operator, from, address(0), ids);
unchecked {
for(uint256 i = 0; i < ids.length; i++) {
amounts[i] = 1;
uint256 id = ids[i];
if(!_owned[from].get(id)) {
revert BurnFromNonOnwerAddress();
}
_owned[from].unset(id);
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids);
}
| 17,007,826 | [
1,
9378,
28599,
2430,
434,
1147,
1953,
316,
1375,
2232,
68,
628,
1375,
2080,
68,
7377,
1282,
279,
288,
5912,
4497,
97,
871,
18,
29076,
30,
300,
1375,
2080,
68,
2780,
506,
326,
3634,
1758,
18,
300,
1375,
2080,
68,
1297,
1240,
326,
1147,
434,
1147,
1953,
316,
1375,
2232,
8338,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
389,
70,
321,
4497,
12,
203,
3639,
1758,
628,
16,
203,
3639,
2254,
5034,
8526,
3778,
3258,
203,
565,
262,
2713,
5024,
288,
203,
3639,
309,
12,
2080,
422,
1758,
12,
20,
3719,
95,
203,
5411,
15226,
605,
321,
1265,
7170,
1887,
5621,
203,
3639,
289,
203,
203,
3639,
1758,
3726,
273,
389,
3576,
12021,
5621,
203,
203,
3639,
2254,
5034,
8526,
3778,
30980,
273,
394,
2254,
5034,
8526,
12,
2232,
18,
2469,
1769,
203,
203,
3639,
389,
5771,
1345,
5912,
12,
9497,
16,
628,
16,
1758,
12,
20,
3631,
3258,
1769,
203,
203,
3639,
22893,
288,
203,
5411,
364,
12,
11890,
5034,
277,
273,
374,
31,
277,
411,
3258,
18,
2469,
31,
277,
27245,
288,
203,
7734,
30980,
63,
77,
65,
273,
404,
31,
203,
7734,
2254,
5034,
612,
273,
3258,
63,
77,
15533,
203,
7734,
309,
12,
5,
67,
995,
329,
63,
2080,
8009,
588,
12,
350,
3719,
288,
203,
10792,
15226,
605,
321,
1265,
3989,
1398,
2051,
1887,
5621,
203,
7734,
289,
203,
7734,
389,
995,
329,
63,
2080,
8009,
18579,
12,
350,
1769,
203,
5411,
289,
203,
3639,
289,
203,
540,
203,
3639,
3626,
12279,
4497,
12,
9497,
16,
628,
16,
1758,
12,
20,
3631,
3258,
16,
30980,
1769,
203,
203,
3639,
389,
5205,
1345,
5912,
12,
9497,
16,
628,
16,
1758,
12,
20,
3631,
3258,
1769,
203,
203,
565,
289,
203,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.2;
// import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
// import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
return interfaceId == type(IERC165).interfaceId;
}
}
/**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/
interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 value
);
/**
* @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
* transfers.
*/
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
/**
* @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
* `approved`.
*/
event ApprovalForAll(
address indexed account,
address indexed operator,
bool approved
);
/**
* @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
*
* If an {URI} event was emitted for `id`, the standard
* https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
* returned by {IERC1155MetadataURI-uri}.
*/
event URI(string value, uint256 indexed id);
/**
* @dev Returns the amount of tokens of token type `id` owned by `account`.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
/**
* @dev xref:ROOT:ERC1155.adoc#batch-operations[Batched] version of {balanceOf}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
/**
* @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
*
* Emits an {ApprovalForAll} event.
*
* Requirements:
*
* - `operator` cannot be the caller.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address account, address operator)
external
view
returns (bool);
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
/**
* @dev xref:ROOT:ERC1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
/**
* @dev Interface of the optional ERC1155MetadataExtension interface, as defined
* in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
*
* _Available since v3.1._
*/
interface IERC1155MetadataURI is IERC1155 {
/**
* @dev Returns the URI for token type `id`.
*
* If the `\{id\}` substring is present in the URI, it must be replaced by
* clients with the actual token type ID.
*/
function uri(uint256 id) external view returns (string memory);
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(
address(this).balance >= amount,
"Address: insufficient balance"
);
(bool success, ) = recipient.call{value: amount}("");
require(
success,
"Address: unable to send value, recipient may have reverted"
);
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return
functionCallWithValue(
target,
data,
value,
"Address: low-level call with value failed"
);
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(
address(this).balance >= value,
"Address: insufficient balance for call"
);
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(
data
);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(
target,
data,
"Address: low-level static call failed"
);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(
target,
data,
"Address: low-level delegate call failed"
);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
struct Metadata {
string name;
string ipfsimage;
string ipfsmetadata;
}
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) public _balances;
mapping(uint256 => Metadata) token_id;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(uint256 => address) public _creator;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
constructor(string memory uri_,string memory name_, string memory symbol_) {
_setURI(uri_);
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the `\{id\}` substring with the
* actual token type ID.
*/
function uri(uint256 tokenId) public view virtual override returns (string memory ipfsmetadata) {
// return _uri;
Metadata memory date = token_id[tokenId];
ipfsmetadata = date.ipfsmetadata;
// string memory ipfsmetadata = getmetadata(tokenId);
return ipfsmetadata;
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id)
public
view
virtual
override
returns (uint256)
{
require(
account != address(0),
"ERC1155: balance query for the zero address"
);
return _balances[id][account];
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(
accounts.length == ids.length,
"ERC1155: accounts and ids length mismatch"
);
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function _setApprovalForAll(address owner,address operator, bool approved)
internal
{
_operatorApprovals[owner][operator] = approved;
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
require(
_msgSender() != operator,
"ERC1155: setting approval status for self"
);
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator)
public
view
virtual
override
returns (bool)
{
return _operatorApprovals[account][operator];
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, address(this)),
"ERC1155: transfer caller is not owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(
operator,
from,
to,
_asSingletonArray(id),
_asSingletonArray(amount),
data
);
uint256 fromBalance = _balances[id][from];
require(
fromBalance >= amount,
"ERC1155: insufficient balance for transfer"
);
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/**
* @dev xref:ROOT:ERC1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(
ids.length == amounts.length,
"ERC1155: ids and amounts length mismatch"
);
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(
fromBalance >= amount,
"ERC1155: insufficient balance for transfer"
);
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(
operator,
from,
to,
ids,
amounts,
data
);
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `account`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - If `account` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(account != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(
operator,
address(0),
account,
_asSingletonArray(id),
_asSingletonArray(amount),
data
);
_balances[id][account] += amount;
emit TransferSingle(operator, address(0), account, id, amount);
_doSafeTransferAcceptanceCheck(
operator,
address(0),
account,
id,
amount,
data
);
}
/**
* @dev xref:ROOT:ERC1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(
ids.length == amounts.length,
"ERC1155: ids and amounts length mismatch"
);
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(
operator,
address(0),
to,
ids,
amounts,
data
);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `account`
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(
operator,
account,
address(0),
_asSingletonArray(id),
_asSingletonArray(amount),
""
);
uint256 accountBalance = _balances[id][account];
require(
accountBalance >= amount,
"ERC1155: burn amount exceeds balance"
);
unchecked {
_balances[id][account] = accountBalance - amount;
}
emit TransferSingle(operator, account, address(0), id, amount);
}
/**
* @dev xref:ROOT:ERC1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
require(
ids.length == amounts.length,
"ERC1155: ids and amounts length mismatch"
);
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 accountBalance = _balances[id][account];
require(
accountBalance >= amount,
"ERC1155: burn amount exceeds balance"
);
unchecked {
_balances[id][account] = accountBalance - amount;
}
}
emit TransferBatch(operator, account, address(0), ids, amounts);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try
IERC1155Receiver(to).onERC1155Received(
operator,
from,
id,
amount,
data
)
returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try
IERC1155Receiver(to).onERC1155BatchReceived(
operator,
from,
ids,
amounts,
data
)
returns (bytes4 response) {
if (
response != IERC1155Receiver.onERC1155BatchReceived.selector
) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element)
private
pure
returns (uint256[] memory)
{
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
/**
* @dev _Available since v3.1._
*/
interface IERC1155Receiver is IERC165 {
/**
@dev Handles the receipt of a single ERC1155 token type. This function is
called at the end of a `safeTransferFrom` after the balance has been updated.
To accept the transfer, this must return
`bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
(i.e. 0xf23a6e61, or its own function selector).
@param operator The address which initiated the transfer (i.e. msg.sender)
@param from The address which previously owned the token
@param id The ID of the token being transferred
@param value The amount of tokens being transferred
@param data Additional data with no specified format
@return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
/**
@dev Handles the receipt of a multiple ERC1155 token types. This function
is called at the end of a `safeBatchTransferFrom` after the balances have
been updated. To accept the transfer(s), this must return
`bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
(i.e. 0xbc197c81, or its own function selector).
@param operator The address which initiated the batch transfer (i.e. msg.sender)
@param from The address which previously owned the token
@param ids An array containing ids of each token being transferred (order and length must match values array)
@param values An array containing amounts of each token being transferred (order and length must match ids array)
@param data Additional data with no specified format
@return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(
newOwner != address(0),
"Ownable: new owner is the zero address"
);
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
/**
* @dev Extension of {ERC1155} that allows token holders to destroy both their
* own tokens and those that they have been approved to use.
*
* _Available since v3.1._
*/
abstract contract ERC1155Burnable is ERC1155, Ownable {
function burn(
address account,
uint256 id,
uint256 value
) public virtual {
require(
account == _msgSender() || isApprovedForAll(account, address(this)) || owner() == _msgSender(),
"ERC1155: caller is not owner nor approved"
);
_burn(account, id, value);
}
function burnBatch(
address account,
uint256[] memory ids,
uint256[] memory values
) public virtual {
require(
account == _msgSender() || isApprovedForAll(account, address(this)),
"ERC1155: caller is not owner nor approved"
);
_burnBatch(account, ids, values);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// interface Woonkly {
// function setApproved(address operator, bool approved) external returns (uint256);
// }
interface ERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract NIFTYSouq1155 is ERC1155, Ownable, ERC1155Burnable{
event Approve(
address indexed owner,
uint256 indexed token_id,
bool approved
);
event OrderPlace(
address indexed from,
uint256 indexed tokenId,
uint256 indexed value
);
event CancelOrder(address indexed from, uint256 indexed tokenId);
event ChangePrice(address indexed from, uint256 indexed tokenId, uint256 indexed value);
using SafeMath for uint256;
struct Order {
uint256 tokenId;
uint256 price;
}
mapping(address => mapping(uint256 => Order)) public order_place;
mapping(uint256 => mapping(address => bool)) public checkOrder;
mapping(uint256 => uint256) public totalQuantity;
mapping(uint256 => uint256) public _royal;
mapping(string => address) private tokentype;
uint256 private serviceValue;
string private _currentBaseURI;
uint256 public _tid;
constructor(
uint256 id,
uint256 _serviceValue,
string memory tokenName,
address tokenAddress,
string memory _name,
string memory _symbol
) ERC1155("",_name,_symbol) {
_tid = id;
serviceValue = _serviceValue;
addTokenType(tokenName,tokenAddress);
}
function getServiceFee() public view returns (uint256) {
return serviceValue;
}
function serviceFunction(uint256 _serviceValue) public onlyOwner{
serviceValue = _serviceValue;
}
function addID(uint256 value) public returns (uint256) {
_tid = _tid + value;
return _tid;
}
function getTokenAddress(string memory _type)
public
view
returns (address)
{
return tokentype[_type];
}
function addTokenType(string memory _type, address tokenAddress)
public
onlyOwner
{
tokentype[_type] = tokenAddress;
}
function setApproval(address operator, bool approved)
public
returns (uint256)
{
setApprovalForAll(operator, approved);
uint256 id_ = addID(1).add(block.timestamp);
emit Approve(msg.sender, id_, approved);
return id_;
}
function mint(uint256 id, uint256 value, uint256 royal, uint256 nooftoken, string memory ipfsname,
string memory ipfsimage,
string memory ipfsmetadata) public {
_mint(msg.sender, id, nooftoken, "");
token_id[id] = Metadata(ipfsname, ipfsimage, ipfsmetadata);
_creator[id]=msg.sender;
_royal[id]=royal.mul(1e18);
if(value != 0){
orderPlace(id, value);
}
}
function mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts
) public {
_mintBatch(to, ids, amounts, "");
}
function saleWithToken(
address payable from,
uint256 tokenId,
uint256 amount,
uint256 nooftoken,
string memory bidtoken
) public{
require(amount == order_place[from][tokenId].price.mul(nooftoken) , "Insufficent Balance");
_saleToken(from, tokenId, amount, bidtoken);
_setApprovalForAll(from, msg.sender,true);
safeTransferFrom(from, msg.sender, tokenId, nooftoken, "");
}
// ETH TRANSFER PURCHASE
function saleToken(
address payable from,
uint256 tokenId,
uint256 amount,
uint256 nooftoken
) public payable {
require(amount == order_place[from][tokenId].price.mul(nooftoken) , "Invalid Balance");
_saleToken(from, tokenId, amount, "BNB");
_setApprovalForAll(from, msg.sender,true);
safeTransferFrom(from, msg.sender, tokenId, nooftoken, "");
}
function _saleToken(
address payable from,
uint256 tokenId,
uint256 amount,
string memory bidtoken
) internal {
uint256 val = pERCent(amount, serviceValue).add(amount);
if(keccak256(abi.encodePacked((bidtoken))) == keccak256(abi.encodePacked(("BNB")))){
require( msg.value == val, "Insufficient Balance");
address payable create = payable(_creator[tokenId]);
(uint256 _adminfee, uint256 roy, uint256 netamount) = calc(amount, _royal[tokenId], serviceValue);
require( msg.value == _adminfee.add(roy.add(netamount)), "Insufficient Balance");
address payable admin = payable(owner());
admin.transfer(_adminfee);
create.transfer(roy);
from.transfer(netamount);
}
else{
ERC20 t = ERC20(tokentype[bidtoken]);
uint256 approveValue = t.allowance(msg.sender, address(this));
require( approveValue >= val, "Insufficient Balance");
(uint256 _adminfee, uint256 roy, uint256 netamount) = calc(amount, _royal[tokenId], serviceValue);
require( approveValue >= _adminfee.add(roy.add(netamount)), "Insufficient Balance");
t.transferFrom(msg.sender, owner(), _adminfee);
t.transferFrom(msg.sender,_creator[tokenId],roy);
t.transferFrom(msg.sender,from,netamount);
}
}
function pERCent(uint256 value1, uint256 value2)
internal
pure
returns (uint256)
{
uint256 result = value1.mul(value2).div(1e20);
return (result);
}
function calc(
uint256 amount,
uint256 royal,
uint256 _serviceValue
)
internal
pure
returns (
uint256,
uint256,
uint256
)
{
uint256 fee = pERCent(amount, _serviceValue);
uint256 roy = pERCent(amount, royal);
uint256 netamount = amount.sub(fee.add(roy));
fee = fee.add(fee);
return (fee, roy, netamount);
}
function acceptBId(string memory bidtoken,address bidaddr, uint256 amount, uint256 tokenId, uint256 NOFToken) public{
_acceptBId(bidtoken, bidaddr, amount, tokenId, owner());
safeTransferFrom(msg.sender,bidaddr, tokenId, NOFToken, "");
if(checkOrder[tokenId][msg.sender] == true){
if(_balances[tokenId][msg.sender] == 0){
delete order_place[msg.sender][tokenId];
checkOrder[tokenId][msg.sender] = false;
}
}
}
function _acceptBId(string memory tokenAss,address from, uint256 amount, uint256 tokenId, address admin) internal{
uint256 val = pERCent(amount, serviceValue).add(amount);
ERC20 t = ERC20(tokentype[tokenAss]);
uint256 approveValue = t.allowance(from, address(this));
require( approveValue >= val, "Insufficient Balance");
require(_balances[tokenId][msg.sender] > 0, "Is Not a Owner");
(uint256 _adminfee, uint256 roy, uint256 netamount) = calc(amount, _royal[tokenId], serviceValue);
require( approveValue >= _adminfee.add(roy.add(netamount)), "Insufficient Balance");
t.transferFrom(from, admin, _adminfee);
t.transferFrom(from,_creator[tokenId],roy);
t.transferFrom(from,msg.sender,netamount);
}
function orderPlace(uint256 tokenId, uint256 _price) public{
require( _balances[tokenId][msg.sender] > 0, "Is Not a Owner");
Order memory order;
order.tokenId = tokenId;
order.price = _price;
order_place[msg.sender][tokenId] = order;
checkOrder[tokenId][msg.sender] = true;
emit OrderPlace(msg.sender, tokenId, _price);
}
function cancelOrder(uint256 tokenId) public{
require(_balances[tokenId][msg.sender] > 0, "Is Not a Owner");
delete order_place[msg.sender][tokenId];
checkOrder[tokenId][msg.sender] = false;
emit CancelOrder(msg.sender, tokenId);
}
function changePrice(uint256 value, uint256 tokenId) public{
require( _balances[tokenId][msg.sender] > 0, "Is Not a Owner");
require( value < order_place[msg.sender][tokenId].price);
order_place[msg.sender][tokenId].price = value;
emit ChangePrice(msg.sender, tokenId, value);
}
function burnToken(address from, uint256 tokenId, uint256 NOFToken ) public{
require( (_balances[tokenId][from] >= NOFToken && from == msg.sender) || msg.sender == owner(), "Your Not a Token Owner or insufficient Token Balance");
require( _balances[tokenId][from] >= NOFToken, "Your Not a Token Owner or insufficient Token Balance");
burn(from, tokenId, NOFToken);
if(_balances[tokenId][from] == NOFToken){
if(checkOrder[tokenId][from]==true){
delete order_place[from][tokenId];
checkOrder[tokenId][from] = false;
}
}
}
} | * @dev See {IERC1155-safeTransferFrom}./ | function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
| 1,451,884 | [
1,
9704,
288,
45,
654,
39,
2499,
2539,
17,
4626,
5912,
1265,
5496,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
377,
445,
4183,
5912,
1265,
12,
203,
3639,
1758,
628,
16,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
612,
16,
203,
3639,
2254,
5034,
3844,
16,
203,
3639,
1731,
3778,
501,
203,
565,
262,
1071,
5024,
3849,
288,
203,
3639,
2583,
12,
203,
5411,
628,
422,
389,
3576,
12021,
1435,
747,
353,
31639,
1290,
1595,
12,
2080,
16,
389,
3576,
12021,
1435,
3631,
203,
5411,
315,
654,
39,
2499,
2539,
30,
4894,
353,
486,
3410,
12517,
20412,
6,
203,
3639,
11272,
203,
3639,
389,
4626,
5912,
1265,
12,
2080,
16,
358,
16,
612,
16,
3844,
16,
501,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// full contract sources : https://github.com/DigixGlobal/dao-contracts
pragma solidity 0.4.25;
// File: @digix/solidity-collections/contracts/abstract/AddressIteratorInteractive.sol
/**
@title Address Iterator Interactive
@author DigixGlobal Pte Ltd
*/
contract AddressIteratorInteractive {
/**
@notice Lists a Address collection from start or end
@param _count Total number of Address items to return
@param _function_first Function that returns the First Address item in the list
@param _function_last Function that returns the last Address item in the list
@param _function_next Function that returns the Next Address item in the list
@param _function_previous Function that returns previous Address item in the list
@param _from_start whether to read from start (or end) of the list
@return {"_address_items" : "Collection of reversed Address list"}
*/
function list_addresses(uint256 _count,
function () external constant returns (address) _function_first,
function () external constant returns (address) _function_last,
function (address) external constant returns (address) _function_next,
function (address) external constant returns (address) _function_previous,
bool _from_start)
internal
constant
returns (address[] _address_items)
{
if (_from_start) {
_address_items = private_list_addresses_from_address(_function_first(), _count, true, _function_last, _function_next);
} else {
_address_items = private_list_addresses_from_address(_function_last(), _count, true, _function_first, _function_previous);
}
}
/**
@notice Lists a Address collection from some `_current_item`, going forwards or backwards depending on `_from_start`
@param _current_item The current Item
@param _count Total number of Address items to return
@param _function_first Function that returns the First Address item in the list
@param _function_last Function that returns the last Address item in the list
@param _function_next Function that returns the Next Address item in the list
@param _function_previous Function that returns previous Address item in the list
@param _from_start whether to read in the forwards ( or backwards) direction
@return {"_address_items" :"Collection/list of Address"}
*/
function list_addresses_from(address _current_item, uint256 _count,
function () external constant returns (address) _function_first,
function () external constant returns (address) _function_last,
function (address) external constant returns (address) _function_next,
function (address) external constant returns (address) _function_previous,
bool _from_start)
internal
constant
returns (address[] _address_items)
{
if (_from_start) {
_address_items = private_list_addresses_from_address(_current_item, _count, false, _function_last, _function_next);
} else {
_address_items = private_list_addresses_from_address(_current_item, _count, false, _function_first, _function_previous);
}
}
/**
@notice a private function to lists a Address collection starting from some `_current_item` (which could be included or excluded), in the forwards or backwards direction
@param _current_item The current Item
@param _count Total number of Address items to return
@param _including_current Whether the `_current_item` should be included in the result
@param _function_last Function that returns the address where we stop reading more address
@param _function_next Function that returns the next address to read after some address (could be backwards or forwards in the physical collection)
@return {"_address_items" :"Collection/list of Address"}
*/
function private_list_addresses_from_address(address _current_item, uint256 _count, bool _including_current,
function () external constant returns (address) _function_last,
function (address) external constant returns (address) _function_next)
private
constant
returns (address[] _address_items)
{
uint256 _i;
uint256 _real_count = 0;
address _last_item;
_last_item = _function_last();
if (_count == 0 || _last_item == address(0x0)) {
_address_items = new address[](0);
} else {
address[] memory _items_temp = new address[](_count);
address _this_item;
if (_including_current == true) {
_items_temp[0] = _current_item;
_real_count = 1;
}
_this_item = _current_item;
for (_i = _real_count; (_i < _count) && (_this_item != _last_item);_i++) {
_this_item = _function_next(_this_item);
if (_this_item != address(0x0)) {
_real_count++;
_items_temp[_i] = _this_item;
}
}
_address_items = new address[](_real_count);
for(_i = 0;_i < _real_count;_i++) {
_address_items[_i] = _items_temp[_i];
}
}
}
/** DEPRECATED
@notice private function to list a Address collection starting from the start or end of the list
@param _count Total number of Address item to return
@param _function_total Function that returns the Total number of Address item in the list
@param _function_first Function that returns the First Address item in the list
@param _function_next Function that returns the Next Address item in the list
@return {"_address_items" :"Collection/list of Address"}
*/
/*function list_addresses_from_start_or_end(uint256 _count,
function () external constant returns (uint256) _function_total,
function () external constant returns (address) _function_first,
function (address) external constant returns (address) _function_next)
private
constant
returns (address[] _address_items)
{
uint256 _i;
address _current_item;
uint256 _real_count = _function_total();
if (_count > _real_count) {
_count = _real_count;
}
address[] memory _items_tmp = new address[](_count);
if (_count > 0) {
_current_item = _function_first();
_items_tmp[0] = _current_item;
for(_i = 1;_i <= (_count - 1);_i++) {
_current_item = _function_next(_current_item);
if (_current_item != address(0x0)) {
_items_tmp[_i] = _current_item;
}
}
_address_items = _items_tmp;
} else {
_address_items = new address[](0);
}
}*/
/** DEPRECATED
@notice a private function to lists a Address collection starting from some `_current_item`, could be forwards or backwards
@param _current_item The current Item
@param _count Total number of Address items to return
@param _function_last Function that returns the bytes where we stop reading more bytes
@param _function_next Function that returns the next bytes to read after some bytes (could be backwards or forwards in the physical collection)
@return {"_address_items" :"Collection/list of Address"}
*/
/*function list_addresses_from_byte(address _current_item, uint256 _count,
function () external constant returns (address) _function_last,
function (address) external constant returns (address) _function_next)
private
constant
returns (address[] _address_items)
{
uint256 _i;
uint256 _real_count = 0;
if (_count == 0) {
_address_items = new address[](0);
} else {
address[] memory _items_temp = new address[](_count);
address _start_item;
address _last_item;
_last_item = _function_last();
if (_last_item != _current_item) {
_start_item = _function_next(_current_item);
if (_start_item != address(0x0)) {
_items_temp[0] = _start_item;
_real_count = 1;
for(_i = 1;(_i <= (_count - 1)) && (_start_item != _last_item);_i++) {
_start_item = _function_next(_start_item);
if (_start_item != address(0x0)) {
_real_count++;
_items_temp[_i] = _start_item;
}
}
_address_items = new address[](_real_count);
for(_i = 0;_i <= (_real_count - 1);_i++) {
_address_items[_i] = _items_temp[_i];
}
} else {
_address_items = new address[](0);
}
} else {
_address_items = new address[](0);
}
}
}*/
}
// File: @digix/solidity-collections/contracts/abstract/BytesIteratorInteractive.sol
/**
@title Bytes Iterator Interactive
@author DigixGlobal Pte Ltd
*/
contract BytesIteratorInteractive {
/**
@notice Lists a Bytes collection from start or end
@param _count Total number of Bytes items to return
@param _function_first Function that returns the First Bytes item in the list
@param _function_last Function that returns the last Bytes item in the list
@param _function_next Function that returns the Next Bytes item in the list
@param _function_previous Function that returns previous Bytes item in the list
@param _from_start whether to read from start (or end) of the list
@return {"_bytes_items" : "Collection of reversed Bytes list"}
*/
function list_bytesarray(uint256 _count,
function () external constant returns (bytes32) _function_first,
function () external constant returns (bytes32) _function_last,
function (bytes32) external constant returns (bytes32) _function_next,
function (bytes32) external constant returns (bytes32) _function_previous,
bool _from_start)
internal
constant
returns (bytes32[] _bytes_items)
{
if (_from_start) {
_bytes_items = private_list_bytes_from_bytes(_function_first(), _count, true, _function_last, _function_next);
} else {
_bytes_items = private_list_bytes_from_bytes(_function_last(), _count, true, _function_first, _function_previous);
}
}
/**
@notice Lists a Bytes collection from some `_current_item`, going forwards or backwards depending on `_from_start`
@param _current_item The current Item
@param _count Total number of Bytes items to return
@param _function_first Function that returns the First Bytes item in the list
@param _function_last Function that returns the last Bytes item in the list
@param _function_next Function that returns the Next Bytes item in the list
@param _function_previous Function that returns previous Bytes item in the list
@param _from_start whether to read in the forwards ( or backwards) direction
@return {"_bytes_items" :"Collection/list of Bytes"}
*/
function list_bytesarray_from(bytes32 _current_item, uint256 _count,
function () external constant returns (bytes32) _function_first,
function () external constant returns (bytes32) _function_last,
function (bytes32) external constant returns (bytes32) _function_next,
function (bytes32) external constant returns (bytes32) _function_previous,
bool _from_start)
internal
constant
returns (bytes32[] _bytes_items)
{
if (_from_start) {
_bytes_items = private_list_bytes_from_bytes(_current_item, _count, false, _function_last, _function_next);
} else {
_bytes_items = private_list_bytes_from_bytes(_current_item, _count, false, _function_first, _function_previous);
}
}
/**
@notice A private function to lists a Bytes collection starting from some `_current_item` (which could be included or excluded), in the forwards or backwards direction
@param _current_item The current Item
@param _count Total number of Bytes items to return
@param _including_current Whether the `_current_item` should be included in the result
@param _function_last Function that returns the bytes where we stop reading more bytes
@param _function_next Function that returns the next bytes to read after some bytes (could be backwards or forwards in the physical collection)
@return {"_address_items" :"Collection/list of Bytes"}
*/
function private_list_bytes_from_bytes(bytes32 _current_item, uint256 _count, bool _including_current,
function () external constant returns (bytes32) _function_last,
function (bytes32) external constant returns (bytes32) _function_next)
private
constant
returns (bytes32[] _bytes32_items)
{
uint256 _i;
uint256 _real_count = 0;
bytes32 _last_item;
_last_item = _function_last();
if (_count == 0 || _last_item == bytes32(0x0)) {
_bytes32_items = new bytes32[](0);
} else {
bytes32[] memory _items_temp = new bytes32[](_count);
bytes32 _this_item;
if (_including_current == true) {
_items_temp[0] = _current_item;
_real_count = 1;
}
_this_item = _current_item;
for (_i = _real_count; (_i < _count) && (_this_item != _last_item);_i++) {
_this_item = _function_next(_this_item);
if (_this_item != bytes32(0x0)) {
_real_count++;
_items_temp[_i] = _this_item;
}
}
_bytes32_items = new bytes32[](_real_count);
for(_i = 0;_i < _real_count;_i++) {
_bytes32_items[_i] = _items_temp[_i];
}
}
}
////// DEPRECATED FUNCTIONS (old versions)
/**
@notice a private function to lists a Bytes collection starting from some `_current_item`, could be forwards or backwards
@param _current_item The current Item
@param _count Total number of Bytes items to return
@param _function_last Function that returns the bytes where we stop reading more bytes
@param _function_next Function that returns the next bytes to read after some bytes (could be backwards or forwards in the physical collection)
@return {"_bytes_items" :"Collection/list of Bytes"}
*/
/*function list_bytes_from_bytes(bytes32 _current_item, uint256 _count,
function () external constant returns (bytes32) _function_last,
function (bytes32) external constant returns (bytes32) _function_next)
private
constant
returns (bytes32[] _bytes_items)
{
uint256 _i;
uint256 _real_count = 0;
if (_count == 0) {
_bytes_items = new bytes32[](0);
} else {
bytes32[] memory _items_temp = new bytes32[](_count);
bytes32 _start_item;
bytes32 _last_item;
_last_item = _function_last();
if (_last_item != _current_item) {
_start_item = _function_next(_current_item);
if (_start_item != bytes32(0x0)) {
_items_temp[0] = _start_item;
_real_count = 1;
for(_i = 1;(_i <= (_count - 1)) && (_start_item != _last_item);_i++) {
_start_item = _function_next(_start_item);
if (_start_item != bytes32(0x0)) {
_real_count++;
_items_temp[_i] = _start_item;
}
}
_bytes_items = new bytes32[](_real_count);
for(_i = 0;_i <= (_real_count - 1);_i++) {
_bytes_items[_i] = _items_temp[_i];
}
} else {
_bytes_items = new bytes32[](0);
}
} else {
_bytes_items = new bytes32[](0);
}
}
}*/
/**
@notice private function to list a Bytes collection starting from the start or end of the list
@param _count Total number of Bytes item to return
@param _function_total Function that returns the Total number of Bytes item in the list
@param _function_first Function that returns the First Bytes item in the list
@param _function_next Function that returns the Next Bytes item in the list
@return {"_bytes_items" :"Collection/list of Bytes"}
*/
/*function list_bytes_from_start_or_end(uint256 _count,
function () external constant returns (uint256) _function_total,
function () external constant returns (bytes32) _function_first,
function (bytes32) external constant returns (bytes32) _function_next)
private
constant
returns (bytes32[] _bytes_items)
{
uint256 _i;
bytes32 _current_item;
uint256 _real_count = _function_total();
if (_count > _real_count) {
_count = _real_count;
}
bytes32[] memory _items_tmp = new bytes32[](_count);
if (_count > 0) {
_current_item = _function_first();
_items_tmp[0] = _current_item;
for(_i = 1;_i <= (_count - 1);_i++) {
_current_item = _function_next(_current_item);
if (_current_item != bytes32(0x0)) {
_items_tmp[_i] = _current_item;
}
}
_bytes_items = _items_tmp;
} else {
_bytes_items = new bytes32[](0);
}
}*/
}
// File: @digix/solidity-collections/contracts/abstract/IndexedBytesIteratorInteractive.sol
/**
@title Indexed Bytes Iterator Interactive
@author DigixGlobal Pte Ltd
*/
contract IndexedBytesIteratorInteractive {
/**
@notice Lists an indexed Bytes collection from start or end
@param _collection_index Index of the Collection to list
@param _count Total number of Bytes items to return
@param _function_first Function that returns the First Bytes item in the list
@param _function_last Function that returns the last Bytes item in the list
@param _function_next Function that returns the Next Bytes item in the list
@param _function_previous Function that returns previous Bytes item in the list
@param _from_start whether to read from start (or end) of the list
@return {"_bytes_items" : "Collection of reversed Bytes list"}
*/
function list_indexed_bytesarray(bytes32 _collection_index, uint256 _count,
function (bytes32) external constant returns (bytes32) _function_first,
function (bytes32) external constant returns (bytes32) _function_last,
function (bytes32, bytes32) external constant returns (bytes32) _function_next,
function (bytes32, bytes32) external constant returns (bytes32) _function_previous,
bool _from_start)
internal
constant
returns (bytes32[] _indexed_bytes_items)
{
if (_from_start) {
_indexed_bytes_items = private_list_indexed_bytes_from_bytes(_collection_index, _function_first(_collection_index), _count, true, _function_last, _function_next);
} else {
_indexed_bytes_items = private_list_indexed_bytes_from_bytes(_collection_index, _function_last(_collection_index), _count, true, _function_first, _function_previous);
}
}
/**
@notice Lists an indexed Bytes collection from some `_current_item`, going forwards or backwards depending on `_from_start`
@param _collection_index Index of the Collection to list
@param _current_item The current Item
@param _count Total number of Bytes items to return
@param _function_first Function that returns the First Bytes item in the list
@param _function_last Function that returns the last Bytes item in the list
@param _function_next Function that returns the Next Bytes item in the list
@param _function_previous Function that returns previous Bytes item in the list
@param _from_start whether to read in the forwards ( or backwards) direction
@return {"_bytes_items" :"Collection/list of Bytes"}
*/
function list_indexed_bytesarray_from(bytes32 _collection_index, bytes32 _current_item, uint256 _count,
function (bytes32) external constant returns (bytes32) _function_first,
function (bytes32) external constant returns (bytes32) _function_last,
function (bytes32, bytes32) external constant returns (bytes32) _function_next,
function (bytes32, bytes32) external constant returns (bytes32) _function_previous,
bool _from_start)
internal
constant
returns (bytes32[] _indexed_bytes_items)
{
if (_from_start) {
_indexed_bytes_items = private_list_indexed_bytes_from_bytes(_collection_index, _current_item, _count, false, _function_last, _function_next);
} else {
_indexed_bytes_items = private_list_indexed_bytes_from_bytes(_collection_index, _current_item, _count, false, _function_first, _function_previous);
}
}
/**
@notice a private function to lists an indexed Bytes collection starting from some `_current_item` (which could be included or excluded), in the forwards or backwards direction
@param _collection_index Index of the Collection to list
@param _current_item The item where we start reading from the list
@param _count Total number of Bytes items to return
@param _including_current Whether the `_current_item` should be included in the result
@param _function_last Function that returns the bytes where we stop reading more bytes
@param _function_next Function that returns the next bytes to read after another bytes (could be backwards or forwards in the physical collection)
@return {"_bytes_items" :"Collection/list of Bytes"}
*/
function private_list_indexed_bytes_from_bytes(bytes32 _collection_index, bytes32 _current_item, uint256 _count, bool _including_current,
function (bytes32) external constant returns (bytes32) _function_last,
function (bytes32, bytes32) external constant returns (bytes32) _function_next)
private
constant
returns (bytes32[] _indexed_bytes_items)
{
uint256 _i;
uint256 _real_count = 0;
bytes32 _last_item;
_last_item = _function_last(_collection_index);
if (_count == 0 || _last_item == bytes32(0x0)) { // if count is 0 or the collection is empty, returns empty array
_indexed_bytes_items = new bytes32[](0);
} else {
bytes32[] memory _items_temp = new bytes32[](_count);
bytes32 _this_item;
if (_including_current) {
_items_temp[0] = _current_item;
_real_count = 1;
}
_this_item = _current_item;
for (_i = _real_count; (_i < _count) && (_this_item != _last_item);_i++) {
_this_item = _function_next(_collection_index, _this_item);
if (_this_item != bytes32(0x0)) {
_real_count++;
_items_temp[_i] = _this_item;
}
}
_indexed_bytes_items = new bytes32[](_real_count);
for(_i = 0;_i < _real_count;_i++) {
_indexed_bytes_items[_i] = _items_temp[_i];
}
}
}
// old function, DEPRECATED
/*function list_indexed_bytes_from_bytes(bytes32 _collection_index, bytes32 _current_item, uint256 _count,
function (bytes32) external constant returns (bytes32) _function_last,
function (bytes32, bytes32) external constant returns (bytes32) _function_next)
private
constant
returns (bytes32[] _indexed_bytes_items)
{
uint256 _i;
uint256 _real_count = 0;
if (_count == 0) {
_indexed_bytes_items = new bytes32[](0);
} else {
bytes32[] memory _items_temp = new bytes32[](_count);
bytes32 _start_item;
bytes32 _last_item;
_last_item = _function_last(_collection_index);
if (_last_item != _current_item) {
_start_item = _function_next(_collection_index, _current_item);
if (_start_item != bytes32(0x0)) {
_items_temp[0] = _start_item;
_real_count = 1;
for(_i = 1;(_i <= (_count - 1)) && (_start_item != _last_item);_i++) {
_start_item = _function_next(_collection_index, _start_item);
if (_start_item != bytes32(0x0)) {
_real_count++;
_items_temp[_i] = _start_item;
}
}
_indexed_bytes_items = new bytes32[](_real_count);
for(_i = 0;_i <= (_real_count - 1);_i++) {
_indexed_bytes_items[_i] = _items_temp[_i];
}
} else {
_indexed_bytes_items = new bytes32[](0);
}
} else {
_indexed_bytes_items = new bytes32[](0);
}
}
}*/
}
// File: @digix/solidity-collections/contracts/lib/DoublyLinkedList.sol
library DoublyLinkedList {
struct Item {
bytes32 item;
uint256 previous_index;
uint256 next_index;
}
struct Data {
uint256 first_index;
uint256 last_index;
uint256 count;
mapping(bytes32 => uint256) item_index;
mapping(uint256 => bool) valid_indexes;
Item[] collection;
}
struct IndexedUint {
mapping(bytes32 => Data) data;
}
struct IndexedAddress {
mapping(bytes32 => Data) data;
}
struct IndexedBytes {
mapping(bytes32 => Data) data;
}
struct Address {
Data data;
}
struct Bytes {
Data data;
}
struct Uint {
Data data;
}
uint256 constant NONE = uint256(0);
bytes32 constant EMPTY_BYTES = bytes32(0x0);
address constant NULL_ADDRESS = address(0x0);
function find(Data storage self, bytes32 _item)
public
constant
returns (uint256 _item_index)
{
if ((self.item_index[_item] == NONE) && (self.count == NONE)) {
_item_index = NONE;
} else {
_item_index = self.item_index[_item];
}
}
function get(Data storage self, uint256 _item_index)
public
constant
returns (bytes32 _item)
{
if (self.valid_indexes[_item_index] == true) {
_item = self.collection[_item_index - 1].item;
} else {
_item = EMPTY_BYTES;
}
}
function append(Data storage self, bytes32 _data)
internal
returns (bool _success)
{
if (find(self, _data) != NONE || _data == bytes32("")) { // rejects addition of empty values
_success = false;
} else {
uint256 _index = uint256(self.collection.push(Item({item: _data, previous_index: self.last_index, next_index: NONE})));
if (self.last_index == NONE) {
if ((self.first_index != NONE) || (self.count != NONE)) {
revert();
} else {
self.first_index = self.last_index = _index;
self.count = 1;
}
} else {
self.collection[self.last_index - 1].next_index = _index;
self.last_index = _index;
self.count++;
}
self.valid_indexes[_index] = true;
self.item_index[_data] = _index;
_success = true;
}
}
function remove(Data storage self, uint256 _index)
internal
returns (bool _success)
{
if (self.valid_indexes[_index] == true) {
Item memory item = self.collection[_index - 1];
if (item.previous_index == NONE) {
self.first_index = item.next_index;
} else {
self.collection[item.previous_index - 1].next_index = item.next_index;
}
if (item.next_index == NONE) {
self.last_index = item.previous_index;
} else {
self.collection[item.next_index - 1].previous_index = item.previous_index;
}
delete self.collection[_index - 1];
self.valid_indexes[_index] = false;
delete self.item_index[item.item];
self.count--;
_success = true;
} else {
_success = false;
}
}
function remove_item(Data storage self, bytes32 _item)
internal
returns (bool _success)
{
uint256 _item_index = find(self, _item);
if (_item_index != NONE) {
require(remove(self, _item_index));
_success = true;
} else {
_success = false;
}
return _success;
}
function total(Data storage self)
public
constant
returns (uint256 _total_count)
{
_total_count = self.count;
}
function start(Data storage self)
public
constant
returns (uint256 _item_index)
{
_item_index = self.first_index;
return _item_index;
}
function start_item(Data storage self)
public
constant
returns (bytes32 _item)
{
uint256 _item_index = start(self);
if (_item_index != NONE) {
_item = get(self, _item_index);
} else {
_item = EMPTY_BYTES;
}
}
function end(Data storage self)
public
constant
returns (uint256 _item_index)
{
_item_index = self.last_index;
return _item_index;
}
function end_item(Data storage self)
public
constant
returns (bytes32 _item)
{
uint256 _item_index = end(self);
if (_item_index != NONE) {
_item = get(self, _item_index);
} else {
_item = EMPTY_BYTES;
}
}
function valid(Data storage self, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = self.valid_indexes[_item_index];
//_yes = ((_item_index - 1) < self.collection.length);
}
function valid_item(Data storage self, bytes32 _item)
public
constant
returns (bool _yes)
{
uint256 _item_index = self.item_index[_item];
_yes = self.valid_indexes[_item_index];
}
function previous(Data storage self, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
if (self.valid_indexes[_current_index] == true) {
_previous_index = self.collection[_current_index - 1].previous_index;
} else {
_previous_index = NONE;
}
}
function previous_item(Data storage self, bytes32 _current_item)
public
constant
returns (bytes32 _previous_item)
{
uint256 _current_index = find(self, _current_item);
if (_current_index != NONE) {
uint256 _previous_index = previous(self, _current_index);
_previous_item = get(self, _previous_index);
} else {
_previous_item = EMPTY_BYTES;
}
}
function next(Data storage self, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
if (self.valid_indexes[_current_index] == true) {
_next_index = self.collection[_current_index - 1].next_index;
} else {
_next_index = NONE;
}
}
function next_item(Data storage self, bytes32 _current_item)
public
constant
returns (bytes32 _next_item)
{
uint256 _current_index = find(self, _current_item);
if (_current_index != NONE) {
uint256 _next_index = next(self, _current_index);
_next_item = get(self, _next_index);
} else {
_next_item = EMPTY_BYTES;
}
}
function find(Uint storage self, uint256 _item)
public
constant
returns (uint256 _item_index)
{
_item_index = find(self.data, bytes32(_item));
}
function get(Uint storage self, uint256 _item_index)
public
constant
returns (uint256 _item)
{
_item = uint256(get(self.data, _item_index));
}
function append(Uint storage self, uint256 _data)
public
returns (bool _success)
{
_success = append(self.data, bytes32(_data));
}
function remove(Uint storage self, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data, _index);
}
function remove_item(Uint storage self, uint256 _item)
public
returns (bool _success)
{
_success = remove_item(self.data, bytes32(_item));
}
function total(Uint storage self)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data);
}
function start(Uint storage self)
public
constant
returns (uint256 _index)
{
_index = start(self.data);
}
function start_item(Uint storage self)
public
constant
returns (uint256 _start_item)
{
_start_item = uint256(start_item(self.data));
}
function end(Uint storage self)
public
constant
returns (uint256 _index)
{
_index = end(self.data);
}
function end_item(Uint storage self)
public
constant
returns (uint256 _end_item)
{
_end_item = uint256(end_item(self.data));
}
function valid(Uint storage self, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data, _item_index);
}
function valid_item(Uint storage self, uint256 _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data, bytes32(_item));
}
function previous(Uint storage self, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data, _current_index);
}
function previous_item(Uint storage self, uint256 _current_item)
public
constant
returns (uint256 _previous_item)
{
_previous_item = uint256(previous_item(self.data, bytes32(_current_item)));
}
function next(Uint storage self, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data, _current_index);
}
function next_item(Uint storage self, uint256 _current_item)
public
constant
returns (uint256 _next_item)
{
_next_item = uint256(next_item(self.data, bytes32(_current_item)));
}
function find(Address storage self, address _item)
public
constant
returns (uint256 _item_index)
{
_item_index = find(self.data, bytes32(_item));
}
function get(Address storage self, uint256 _item_index)
public
constant
returns (address _item)
{
_item = address(get(self.data, _item_index));
}
function find(IndexedUint storage self, bytes32 _collection_index, uint256 _item)
public
constant
returns (uint256 _item_index)
{
_item_index = find(self.data[_collection_index], bytes32(_item));
}
function get(IndexedUint storage self, bytes32 _collection_index, uint256 _item_index)
public
constant
returns (uint256 _item)
{
_item = uint256(get(self.data[_collection_index], _item_index));
}
function append(IndexedUint storage self, bytes32 _collection_index, uint256 _data)
public
returns (bool _success)
{
_success = append(self.data[_collection_index], bytes32(_data));
}
function remove(IndexedUint storage self, bytes32 _collection_index, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data[_collection_index], _index);
}
function remove_item(IndexedUint storage self, bytes32 _collection_index, uint256 _item)
public
returns (bool _success)
{
_success = remove_item(self.data[_collection_index], bytes32(_item));
}
function total(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data[_collection_index]);
}
function start(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = start(self.data[_collection_index]);
}
function start_item(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _start_item)
{
_start_item = uint256(start_item(self.data[_collection_index]));
}
function end(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = end(self.data[_collection_index]);
}
function end_item(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _end_item)
{
_end_item = uint256(end_item(self.data[_collection_index]));
}
function valid(IndexedUint storage self, bytes32 _collection_index, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data[_collection_index], _item_index);
}
function valid_item(IndexedUint storage self, bytes32 _collection_index, uint256 _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data[_collection_index], bytes32(_item));
}
function previous(IndexedUint storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data[_collection_index], _current_index);
}
function previous_item(IndexedUint storage self, bytes32 _collection_index, uint256 _current_item)
public
constant
returns (uint256 _previous_item)
{
_previous_item = uint256(previous_item(self.data[_collection_index], bytes32(_current_item)));
}
function next(IndexedUint storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data[_collection_index], _current_index);
}
function next_item(IndexedUint storage self, bytes32 _collection_index, uint256 _current_item)
public
constant
returns (uint256 _next_item)
{
_next_item = uint256(next_item(self.data[_collection_index], bytes32(_current_item)));
}
function append(Address storage self, address _data)
public
returns (bool _success)
{
_success = append(self.data, bytes32(_data));
}
function remove(Address storage self, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data, _index);
}
function remove_item(Address storage self, address _item)
public
returns (bool _success)
{
_success = remove_item(self.data, bytes32(_item));
}
function total(Address storage self)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data);
}
function start(Address storage self)
public
constant
returns (uint256 _index)
{
_index = start(self.data);
}
function start_item(Address storage self)
public
constant
returns (address _start_item)
{
_start_item = address(start_item(self.data));
}
function end(Address storage self)
public
constant
returns (uint256 _index)
{
_index = end(self.data);
}
function end_item(Address storage self)
public
constant
returns (address _end_item)
{
_end_item = address(end_item(self.data));
}
function valid(Address storage self, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data, _item_index);
}
function valid_item(Address storage self, address _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data, bytes32(_item));
}
function previous(Address storage self, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data, _current_index);
}
function previous_item(Address storage self, address _current_item)
public
constant
returns (address _previous_item)
{
_previous_item = address(previous_item(self.data, bytes32(_current_item)));
}
function next(Address storage self, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data, _current_index);
}
function next_item(Address storage self, address _current_item)
public
constant
returns (address _next_item)
{
_next_item = address(next_item(self.data, bytes32(_current_item)));
}
function append(IndexedAddress storage self, bytes32 _collection_index, address _data)
public
returns (bool _success)
{
_success = append(self.data[_collection_index], bytes32(_data));
}
function remove(IndexedAddress storage self, bytes32 _collection_index, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data[_collection_index], _index);
}
function remove_item(IndexedAddress storage self, bytes32 _collection_index, address _item)
public
returns (bool _success)
{
_success = remove_item(self.data[_collection_index], bytes32(_item));
}
function total(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data[_collection_index]);
}
function start(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = start(self.data[_collection_index]);
}
function start_item(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (address _start_item)
{
_start_item = address(start_item(self.data[_collection_index]));
}
function end(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = end(self.data[_collection_index]);
}
function end_item(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (address _end_item)
{
_end_item = address(end_item(self.data[_collection_index]));
}
function valid(IndexedAddress storage self, bytes32 _collection_index, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data[_collection_index], _item_index);
}
function valid_item(IndexedAddress storage self, bytes32 _collection_index, address _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data[_collection_index], bytes32(_item));
}
function previous(IndexedAddress storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data[_collection_index], _current_index);
}
function previous_item(IndexedAddress storage self, bytes32 _collection_index, address _current_item)
public
constant
returns (address _previous_item)
{
_previous_item = address(previous_item(self.data[_collection_index], bytes32(_current_item)));
}
function next(IndexedAddress storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data[_collection_index], _current_index);
}
function next_item(IndexedAddress storage self, bytes32 _collection_index, address _current_item)
public
constant
returns (address _next_item)
{
_next_item = address(next_item(self.data[_collection_index], bytes32(_current_item)));
}
function find(Bytes storage self, bytes32 _item)
public
constant
returns (uint256 _item_index)
{
_item_index = find(self.data, _item);
}
function get(Bytes storage self, uint256 _item_index)
public
constant
returns (bytes32 _item)
{
_item = get(self.data, _item_index);
}
function append(Bytes storage self, bytes32 _data)
public
returns (bool _success)
{
_success = append(self.data, _data);
}
function remove(Bytes storage self, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data, _index);
}
function remove_item(Bytes storage self, bytes32 _item)
public
returns (bool _success)
{
_success = remove_item(self.data, _item);
}
function total(Bytes storage self)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data);
}
function start(Bytes storage self)
public
constant
returns (uint256 _index)
{
_index = start(self.data);
}
function start_item(Bytes storage self)
public
constant
returns (bytes32 _start_item)
{
_start_item = start_item(self.data);
}
function end(Bytes storage self)
public
constant
returns (uint256 _index)
{
_index = end(self.data);
}
function end_item(Bytes storage self)
public
constant
returns (bytes32 _end_item)
{
_end_item = end_item(self.data);
}
function valid(Bytes storage self, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data, _item_index);
}
function valid_item(Bytes storage self, bytes32 _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data, _item);
}
function previous(Bytes storage self, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data, _current_index);
}
function previous_item(Bytes storage self, bytes32 _current_item)
public
constant
returns (bytes32 _previous_item)
{
_previous_item = previous_item(self.data, _current_item);
}
function next(Bytes storage self, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data, _current_index);
}
function next_item(Bytes storage self, bytes32 _current_item)
public
constant
returns (bytes32 _next_item)
{
_next_item = next_item(self.data, _current_item);
}
function append(IndexedBytes storage self, bytes32 _collection_index, bytes32 _data)
public
returns (bool _success)
{
_success = append(self.data[_collection_index], bytes32(_data));
}
function remove(IndexedBytes storage self, bytes32 _collection_index, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data[_collection_index], _index);
}
function remove_item(IndexedBytes storage self, bytes32 _collection_index, bytes32 _item)
public
returns (bool _success)
{
_success = remove_item(self.data[_collection_index], bytes32(_item));
}
function total(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data[_collection_index]);
}
function start(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = start(self.data[_collection_index]);
}
function start_item(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (bytes32 _start_item)
{
_start_item = bytes32(start_item(self.data[_collection_index]));
}
function end(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = end(self.data[_collection_index]);
}
function end_item(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (bytes32 _end_item)
{
_end_item = bytes32(end_item(self.data[_collection_index]));
}
function valid(IndexedBytes storage self, bytes32 _collection_index, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data[_collection_index], _item_index);
}
function valid_item(IndexedBytes storage self, bytes32 _collection_index, bytes32 _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data[_collection_index], bytes32(_item));
}
function previous(IndexedBytes storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data[_collection_index], _current_index);
}
function previous_item(IndexedBytes storage self, bytes32 _collection_index, bytes32 _current_item)
public
constant
returns (bytes32 _previous_item)
{
_previous_item = bytes32(previous_item(self.data[_collection_index], bytes32(_current_item)));
}
function next(IndexedBytes storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data[_collection_index], _current_index);
}
function next_item(IndexedBytes storage self, bytes32 _collection_index, bytes32 _current_item)
public
constant
returns (bytes32 _next_item)
{
_next_item = bytes32(next_item(self.data[_collection_index], bytes32(_current_item)));
}
}
// File: @digix/solidity-collections/contracts/abstract/BytesIteratorStorage.sol
/**
@title Bytes Iterator Storage
@author DigixGlobal Pte Ltd
*/
contract BytesIteratorStorage {
// Initialize Doubly Linked List of Bytes
using DoublyLinkedList for DoublyLinkedList.Bytes;
/**
@notice Reads the first item from the list of Bytes
@param _list The source list
@return {"_item": "The first item from the list"}
*/
function read_first_from_bytesarray(DoublyLinkedList.Bytes storage _list)
internal
constant
returns (bytes32 _item)
{
_item = _list.start_item();
}
/**
@notice Reads the last item from the list of Bytes
@param _list The source list
@return {"_item": "The last item from the list"}
*/
function read_last_from_bytesarray(DoublyLinkedList.Bytes storage _list)
internal
constant
returns (bytes32 _item)
{
_item = _list.end_item();
}
/**
@notice Reads the next item on the list of Bytes
@param _list The source list
@param _current_item The current item to be used as base line
@return {"_item": "The next item from the list based on the specieid `_current_item`"}
TODO: Need to verify what happens if the specified `_current_item` is the last item from the list
*/
function read_next_from_bytesarray(DoublyLinkedList.Bytes storage _list, bytes32 _current_item)
internal
constant
returns (bytes32 _item)
{
_item = _list.next_item(_current_item);
}
/**
@notice Reads the previous item on the list of Bytes
@param _list The source list
@param _current_item The current item to be used as base line
@return {"_item": "The previous item from the list based on the spcified `_current_item`"}
TODO: Need to verify what happens if the specified `_current_item` is the first item from the list
*/
function read_previous_from_bytesarray(DoublyLinkedList.Bytes storage _list, bytes32 _current_item)
internal
constant
returns (bytes32 _item)
{
_item = _list.previous_item(_current_item);
}
/**
@notice Reads the list of Bytes and returns the length of the list
@param _list The source list
@return {"count": "`uint256` The lenght of the list"}
*/
function read_total_bytesarray(DoublyLinkedList.Bytes storage _list)
internal
constant
returns (uint256 _count)
{
_count = _list.total();
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: contracts/common/DaoConstants.sol
contract DaoConstants {
using SafeMath for uint256;
bytes32 EMPTY_BYTES = bytes32(0x0);
address EMPTY_ADDRESS = address(0x0);
bytes32 PROPOSAL_STATE_PREPROPOSAL = "proposal_state_preproposal";
bytes32 PROPOSAL_STATE_DRAFT = "proposal_state_draft";
bytes32 PROPOSAL_STATE_MODERATED = "proposal_state_moderated";
bytes32 PROPOSAL_STATE_ONGOING = "proposal_state_ongoing";
bytes32 PROPOSAL_STATE_CLOSED = "proposal_state_closed";
bytes32 PROPOSAL_STATE_ARCHIVED = "proposal_state_archived";
uint256 PRL_ACTION_STOP = 1;
uint256 PRL_ACTION_PAUSE = 2;
uint256 PRL_ACTION_UNPAUSE = 3;
uint256 COLLATERAL_STATUS_UNLOCKED = 1;
uint256 COLLATERAL_STATUS_LOCKED = 2;
uint256 COLLATERAL_STATUS_CLAIMED = 3;
bytes32 INTERMEDIATE_DGD_IDENTIFIER = "inter_dgd_id";
bytes32 INTERMEDIATE_MODERATOR_DGD_IDENTIFIER = "inter_mod_dgd_id";
bytes32 INTERMEDIATE_BONUS_CALCULATION_IDENTIFIER = "inter_bonus_calculation_id";
// interactive contracts
bytes32 CONTRACT_DAO = "dao";
bytes32 CONTRACT_DAO_SPECIAL_PROPOSAL = "dao:special:proposal";
bytes32 CONTRACT_DAO_STAKE_LOCKING = "dao:stake-locking";
bytes32 CONTRACT_DAO_VOTING = "dao:voting";
bytes32 CONTRACT_DAO_VOTING_CLAIMS = "dao:voting:claims";
bytes32 CONTRACT_DAO_SPECIAL_VOTING_CLAIMS = "dao:svoting:claims";
bytes32 CONTRACT_DAO_IDENTITY = "dao:identity";
bytes32 CONTRACT_DAO_REWARDS_MANAGER = "dao:rewards-manager";
bytes32 CONTRACT_DAO_REWARDS_MANAGER_EXTRAS = "dao:rewards-extras";
bytes32 CONTRACT_DAO_ROLES = "dao:roles";
bytes32 CONTRACT_DAO_FUNDING_MANAGER = "dao:funding-manager";
bytes32 CONTRACT_DAO_WHITELISTING = "dao:whitelisting";
bytes32 CONTRACT_DAO_INFORMATION = "dao:information";
// service contracts
bytes32 CONTRACT_SERVICE_ROLE = "service:role";
bytes32 CONTRACT_SERVICE_DAO_INFO = "service:dao:info";
bytes32 CONTRACT_SERVICE_DAO_LISTING = "service:dao:listing";
bytes32 CONTRACT_SERVICE_DAO_CALCULATOR = "service:dao:calculator";
// storage contracts
bytes32 CONTRACT_STORAGE_DAO = "storage:dao";
bytes32 CONTRACT_STORAGE_DAO_COUNTER = "storage:dao:counter";
bytes32 CONTRACT_STORAGE_DAO_UPGRADE = "storage:dao:upgrade";
bytes32 CONTRACT_STORAGE_DAO_IDENTITY = "storage:dao:identity";
bytes32 CONTRACT_STORAGE_DAO_POINTS = "storage:dao:points";
bytes32 CONTRACT_STORAGE_DAO_SPECIAL = "storage:dao:special";
bytes32 CONTRACT_STORAGE_DAO_CONFIG = "storage:dao:config";
bytes32 CONTRACT_STORAGE_DAO_STAKE = "storage:dao:stake";
bytes32 CONTRACT_STORAGE_DAO_REWARDS = "storage:dao:rewards";
bytes32 CONTRACT_STORAGE_DAO_WHITELISTING = "storage:dao:whitelisting";
bytes32 CONTRACT_STORAGE_INTERMEDIATE_RESULTS = "storage:intermediate:results";
bytes32 CONTRACT_DGD_TOKEN = "t:dgd";
bytes32 CONTRACT_DGX_TOKEN = "t:dgx";
bytes32 CONTRACT_BADGE_TOKEN = "t:badge";
uint8 ROLES_ROOT = 1;
uint8 ROLES_FOUNDERS = 2;
uint8 ROLES_PRLS = 3;
uint8 ROLES_KYC_ADMINS = 4;
uint256 QUARTER_DURATION = 90 days;
bytes32 CONFIG_MINIMUM_LOCKED_DGD = "min_dgd_participant";
bytes32 CONFIG_MINIMUM_DGD_FOR_MODERATOR = "min_dgd_moderator";
bytes32 CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR = "min_reputation_moderator";
bytes32 CONFIG_LOCKING_PHASE_DURATION = "locking_phase_duration";
bytes32 CONFIG_QUARTER_DURATION = "quarter_duration";
bytes32 CONFIG_VOTING_COMMIT_PHASE = "voting_commit_phase";
bytes32 CONFIG_VOTING_PHASE_TOTAL = "voting_phase_total";
bytes32 CONFIG_INTERIM_COMMIT_PHASE = "interim_voting_commit_phase";
bytes32 CONFIG_INTERIM_PHASE_TOTAL = "interim_voting_phase_total";
bytes32 CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR = "draft_quorum_fixed_numerator";
bytes32 CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR = "draft_quorum_fixed_denominator";
bytes32 CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR = "draft_quorum_sfactor_numerator";
bytes32 CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR = "draft_quorum_sfactor_denominator";
bytes32 CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR = "vote_quorum_fixed_numerator";
bytes32 CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR = "vote_quorum_fixed_denominator";
bytes32 CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR = "vote_quorum_sfactor_numerator";
bytes32 CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR = "vote_quorum_sfactor_denominator";
bytes32 CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR = "final_reward_sfactor_numerator";
bytes32 CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR = "final_reward_sfactor_denominator";
bytes32 CONFIG_DRAFT_QUOTA_NUMERATOR = "draft_quota_numerator";
bytes32 CONFIG_DRAFT_QUOTA_DENOMINATOR = "draft_quota_denominator";
bytes32 CONFIG_VOTING_QUOTA_NUMERATOR = "voting_quota_numerator";
bytes32 CONFIG_VOTING_QUOTA_DENOMINATOR = "voting_quota_denominator";
bytes32 CONFIG_MINIMAL_QUARTER_POINT = "minimal_qp";
bytes32 CONFIG_QUARTER_POINT_SCALING_FACTOR = "quarter_point_scaling_factor";
bytes32 CONFIG_REPUTATION_POINT_SCALING_FACTOR = "rep_point_scaling_factor";
bytes32 CONFIG_MODERATOR_MINIMAL_QUARTER_POINT = "minimal_mod_qp";
bytes32 CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR = "mod_qp_scaling_factor";
bytes32 CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR = "mod_rep_point_scaling_factor";
bytes32 CONFIG_QUARTER_POINT_DRAFT_VOTE = "quarter_point_draft_vote";
bytes32 CONFIG_QUARTER_POINT_VOTE = "quarter_point_vote";
bytes32 CONFIG_QUARTER_POINT_INTERIM_VOTE = "quarter_point_interim_vote";
/// this is per 10000 ETHs
bytes32 CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH = "q_p_milestone_completion";
bytes32 CONFIG_BONUS_REPUTATION_NUMERATOR = "bonus_reputation_numerator";
bytes32 CONFIG_BONUS_REPUTATION_DENOMINATOR = "bonus_reputation_denominator";
bytes32 CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE = "special_proposal_commit_phase";
bytes32 CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL = "special_proposal_phase_total";
bytes32 CONFIG_SPECIAL_QUOTA_NUMERATOR = "config_special_quota_numerator";
bytes32 CONFIG_SPECIAL_QUOTA_DENOMINATOR = "config_special_quota_denominator";
bytes32 CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR = "special_quorum_numerator";
bytes32 CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR = "special_quorum_denominator";
bytes32 CONFIG_MAXIMUM_REPUTATION_DEDUCTION = "config_max_reputation_deduction";
bytes32 CONFIG_PUNISHMENT_FOR_NOT_LOCKING = "config_punishment_not_locking";
bytes32 CONFIG_REPUTATION_PER_EXTRA_QP_NUM = "config_rep_per_extra_qp_num";
bytes32 CONFIG_REPUTATION_PER_EXTRA_QP_DEN = "config_rep_per_extra_qp_den";
bytes32 CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION = "config_max_m_rp_deduction";
bytes32 CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM = "config_rep_per_extra_m_qp_num";
bytes32 CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN = "config_rep_per_extra_m_qp_den";
bytes32 CONFIG_PORTION_TO_MODERATORS_NUM = "config_mod_portion_num";
bytes32 CONFIG_PORTION_TO_MODERATORS_DEN = "config_mod_portion_den";
bytes32 CONFIG_DRAFT_VOTING_PHASE = "config_draft_voting_phase";
bytes32 CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE = "config_rp_boost_per_badge";
bytes32 CONFIG_VOTE_CLAIMING_DEADLINE = "config_claiming_deadline";
bytes32 CONFIG_PREPROPOSAL_COLLATERAL = "config_preproposal_collateral";
bytes32 CONFIG_MAX_FUNDING_FOR_NON_DIGIX = "config_max_funding_nonDigix";
bytes32 CONFIG_MAX_MILESTONES_FOR_NON_DIGIX = "config_max_milestones_nonDigix";
bytes32 CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER = "config_nonDigix_proposal_cap";
bytes32 CONFIG_PROPOSAL_DEAD_DURATION = "config_dead_duration";
bytes32 CONFIG_CARBON_VOTE_REPUTATION_BONUS = "config_cv_reputation";
}
// File: @digix/cacp-contracts-dao/contracts/ACOwned.sol
/// @title Owner based access control
/// @author DigixGlobal
contract ACOwned {
address public owner;
address public new_owner;
bool is_ac_owned_init;
/// @dev Modifier to check if msg.sender is the contract owner
modifier if_owner() {
require(is_owner());
_;
}
function init_ac_owned()
internal
returns (bool _success)
{
if (is_ac_owned_init == false) {
owner = msg.sender;
is_ac_owned_init = true;
}
_success = true;
}
function is_owner()
private
constant
returns (bool _is_owner)
{
_is_owner = (msg.sender == owner);
}
function change_owner(address _new_owner)
if_owner()
public
returns (bool _success)
{
new_owner = _new_owner;
_success = true;
}
function claim_ownership()
public
returns (bool _success)
{
require(msg.sender == new_owner);
owner = new_owner;
_success = true;
}
}
// File: @digix/cacp-contracts-dao/contracts/Constants.sol
/// @title Some useful constants
/// @author DigixGlobal
contract Constants {
address constant NULL_ADDRESS = address(0x0);
uint256 constant ZERO = uint256(0);
bytes32 constant EMPTY = bytes32(0x0);
}
// File: @digix/cacp-contracts-dao/contracts/ContractResolver.sol
/// @title Contract Name Registry
/// @author DigixGlobal
contract ContractResolver is ACOwned, Constants {
mapping (bytes32 => address) contracts;
bool public locked_forever;
modifier unless_registered(bytes32 _key) {
require(contracts[_key] == NULL_ADDRESS);
_;
}
modifier if_owner_origin() {
require(tx.origin == owner);
_;
}
/// Function modifier to check if msg.sender corresponds to the resolved address of a given key
/// @param _contract The resolver key
modifier if_sender_is(bytes32 _contract) {
require(msg.sender == get_contract(_contract));
_;
}
modifier if_not_locked() {
require(locked_forever == false);
_;
}
/// @dev ContractResolver constructor will perform the following: 1. Set msg.sender as the contract owner.
constructor() public
{
require(init_ac_owned());
locked_forever = false;
}
/// @dev Called at contract initialization
/// @param _key bytestring for CACP name
/// @param _contract_address The address of the contract to be registered
/// @return _success if the operation is successful
function init_register_contract(bytes32 _key, address _contract_address)
if_owner_origin()
if_not_locked()
unless_registered(_key)
public
returns (bool _success)
{
require(_contract_address != NULL_ADDRESS);
contracts[_key] = _contract_address;
_success = true;
}
/// @dev Lock the resolver from any further modifications. This can only be called from the owner
/// @return _success if the operation is successful
function lock_resolver_forever()
if_owner
public
returns (bool _success)
{
locked_forever = true;
_success = true;
}
/// @dev Get address of a contract
/// @param _key the bytestring name of the contract to look up
/// @return _contract the address of the contract
function get_contract(bytes32 _key)
public
view
returns (address _contract)
{
require(contracts[_key] != NULL_ADDRESS);
_contract = contracts[_key];
}
}
// File: @digix/cacp-contracts-dao/contracts/ResolverClient.sol
/// @title Contract Resolver Interface
/// @author DigixGlobal
contract ResolverClient {
/// The address of the resolver contract for this project
address public resolver;
bytes32 public key;
/// Make our own address available to us as a constant
address public CONTRACT_ADDRESS;
/// Function modifier to check if msg.sender corresponds to the resolved address of a given key
/// @param _contract The resolver key
modifier if_sender_is(bytes32 _contract) {
require(sender_is(_contract));
_;
}
function sender_is(bytes32 _contract) internal view returns (bool _isFrom) {
_isFrom = msg.sender == ContractResolver(resolver).get_contract(_contract);
}
modifier if_sender_is_from(bytes32[3] _contracts) {
require(sender_is_from(_contracts));
_;
}
function sender_is_from(bytes32[3] _contracts) internal view returns (bool _isFrom) {
uint256 _n = _contracts.length;
for (uint256 i = 0; i < _n; i++) {
if (_contracts[i] == bytes32(0x0)) continue;
if (msg.sender == ContractResolver(resolver).get_contract(_contracts[i])) {
_isFrom = true;
break;
}
}
}
/// Function modifier to check resolver's locking status.
modifier unless_resolver_is_locked() {
require(is_locked() == false);
_;
}
/// @dev Initialize new contract
/// @param _key the resolver key for this contract
/// @return _success if the initialization is successful
function init(bytes32 _key, address _resolver)
internal
returns (bool _success)
{
bool _is_locked = ContractResolver(_resolver).locked_forever();
if (_is_locked == false) {
CONTRACT_ADDRESS = address(this);
resolver = _resolver;
key = _key;
require(ContractResolver(resolver).init_register_contract(key, CONTRACT_ADDRESS));
_success = true;
} else {
_success = false;
}
}
/// @dev Check if resolver is locked
/// @return _locked if the resolver is currently locked
function is_locked()
private
view
returns (bool _locked)
{
_locked = ContractResolver(resolver).locked_forever();
}
/// @dev Get the address of a contract
/// @param _key the resolver key to look up
/// @return _contract the address of the contract
function get_contract(bytes32 _key)
public
view
returns (address _contract)
{
_contract = ContractResolver(resolver).get_contract(_key);
}
}
// File: contracts/storage/DaoWhitelistingStorage.sol
// This contract is basically created to restrict read access to
// ethereum accounts, and whitelisted contracts
contract DaoWhitelistingStorage is ResolverClient, DaoConstants {
// we want to avoid the scenario in which an on-chain bribing contract
// can be deployed to distribute funds in a trustless way by verifying
// on-chain votes. This mapping marks whether a contract address is whitelisted
// to read from the read functions in DaoStorage, DaoSpecialStorage, etc.
mapping (address => bool) public whitelist;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_WHITELISTING, _resolver));
}
function setWhitelisted(address _contractAddress, bool _senderIsAllowedToRead)
public
{
require(sender_is(CONTRACT_DAO_WHITELISTING));
whitelist[_contractAddress] = _senderIsAllowedToRead;
}
}
// File: contracts/common/DaoWhitelistingCommon.sol
contract DaoWhitelistingCommon is ResolverClient, DaoConstants {
function daoWhitelistingStorage()
internal
view
returns (DaoWhitelistingStorage _contract)
{
_contract = DaoWhitelistingStorage(get_contract(CONTRACT_STORAGE_DAO_WHITELISTING));
}
/**
@notice Check if a certain address is whitelisted to read sensitive information in the storage layer
@dev if the address is an account, it is allowed to read. If the address is a contract, it has to be in the whitelist
*/
function senderIsAllowedToRead()
internal
view
returns (bool _senderIsAllowedToRead)
{
// msg.sender is allowed to read only if its an EOA or a whitelisted contract
_senderIsAllowedToRead = (msg.sender == tx.origin) || daoWhitelistingStorage().whitelist(msg.sender);
}
}
// File: contracts/lib/DaoStructs.sol
library DaoStructs {
using DoublyLinkedList for DoublyLinkedList.Bytes;
using SafeMath for uint256;
bytes32 constant EMPTY_BYTES = bytes32(0x0);
struct PrlAction {
// UTC timestamp at which the PRL action was done
uint256 at;
// IPFS hash of the document summarizing the action
bytes32 doc;
// Type of action
// check PRL_ACTION_* in "./../common/DaoConstants.sol"
uint256 actionId;
}
struct Voting {
// UTC timestamp at which the voting round starts
uint256 startTime;
// Mapping of whether a commit was used in this voting round
mapping (bytes32 => bool) usedCommits;
// Mapping of commits by address. These are the commits during the commit phase in a voting round
// This only stores the most recent commit in the voting round
// In case a vote is edited, the previous commit is overwritten by the new commit
// Only this new commit is verified at the reveal phase
mapping (address => bytes32) commits;
// This mapping is updated after the reveal phase, when votes are revealed
// It is a mapping of address to weight of vote
// Weight implies the lockedDGDStake of the address, at the time of revealing
// If the address voted "NO", or didn't vote, this would be 0
mapping (address => uint256) yesVotes;
// This mapping is updated after the reveal phase, when votes are revealed
// It is a mapping of address to weight of vote
// Weight implies the lockedDGDStake of the address, at the time of revealing
// If the address voted "YES", or didn't vote, this would be 0
mapping (address => uint256) noVotes;
// Boolean whether the voting round passed or not
bool passed;
// Boolean whether the voting round results were claimed or not
// refer the claimProposalVotingResult function in "./../interative/DaoVotingClaims.sol"
bool claimed;
// Boolean whether the milestone following this voting round was funded or not
// The milestone is funded when the proposer calls claimFunding in "./../interactive/DaoFundingManager.sol"
bool funded;
}
struct ProposalVersion {
// IPFS doc hash of this version of the proposal
bytes32 docIpfsHash;
// UTC timestamp at which this version was created
uint256 created;
// The number of milestones in the proposal as per this version
uint256 milestoneCount;
// The final reward asked by the proposer for completion of the entire proposal
uint256 finalReward;
// List of fundings required by the proposal as per this version
// The numbers are in wei
uint256[] milestoneFundings;
// When a proposal is finalized (calling Dao.finalizeProposal), the proposer can no longer add proposal versions
// However, they can still add more details to this final proposal version, in the form of IPFS docs.
// These IPFS docs are stored in this array
bytes32[] moreDocs;
}
struct Proposal {
// ID of the proposal. Also the IPFS hash of the first ProposalVersion
bytes32 proposalId;
// current state of the proposal
// refer PROPOSAL_STATE_* in "./../common/DaoConstants.sol"
bytes32 currentState;
// UTC timestamp at which the proposal was created
uint256 timeCreated;
// DoublyLinkedList of IPFS doc hashes of the various versions of the proposal
DoublyLinkedList.Bytes proposalVersionDocs;
// Mapping of version (IPFS doc hash) to ProposalVersion struct
mapping (bytes32 => ProposalVersion) proposalVersions;
// Voting struct for the draft voting round
Voting draftVoting;
// Mapping of voting round index (starts from 0) to Voting struct
// votingRounds[0] is the Voting round of the proposal, which lasts for get_uint_config(CONFIG_VOTING_PHASE_TOTAL)
// votingRounds[i] for i>0 are the Interim Voting rounds of the proposal, which lasts for get_uint_config(CONFIG_INTERIM_PHASE_TOTAL)
mapping (uint256 => Voting) votingRounds;
// Every proposal has a collateral tied to it with a value of
// get_uint_config(CONFIG_PREPROPOSAL_COLLATERAL) (refer "./../storage/DaoConfigsStorage.sol")
// Collateral can be in different states
// refer COLLATERAL_STATUS_* in "./../common/DaoConstants.sol"
uint256 collateralStatus;
uint256 collateralAmount;
// The final version of the proposal
// Every proposal needs to be finalized before it can be voted on
// This is the IPFS doc hash of the final version
bytes32 finalVersion;
// List of PrlAction structs
// These are all the actions done by the PRL on the proposal
PrlAction[] prlActions;
// Address of the user who created the proposal
address proposer;
// Address of the moderator who endorsed the proposal
address endorser;
// Boolean whether the proposal is paused/stopped at the moment
bool isPausedOrStopped;
// Boolean whether the proposal was created by a founder role
bool isDigix;
}
function countVotes(Voting storage _voting, address[] _allUsers)
external
view
returns (uint256 _for, uint256 _against)
{
uint256 _n = _allUsers.length;
for (uint256 i = 0; i < _n; i++) {
if (_voting.yesVotes[_allUsers[i]] > 0) {
_for = _for.add(_voting.yesVotes[_allUsers[i]]);
} else if (_voting.noVotes[_allUsers[i]] > 0) {
_against = _against.add(_voting.noVotes[_allUsers[i]]);
}
}
}
// get the list of voters who voted _vote (true-yes/false-no)
function listVotes(Voting storage _voting, address[] _allUsers, bool _vote)
external
view
returns (address[] memory _voters, uint256 _length)
{
uint256 _n = _allUsers.length;
uint256 i;
_length = 0;
_voters = new address[](_n);
if (_vote == true) {
for (i = 0; i < _n; i++) {
if (_voting.yesVotes[_allUsers[i]] > 0) {
_voters[_length] = _allUsers[i];
_length++;
}
}
} else {
for (i = 0; i < _n; i++) {
if (_voting.noVotes[_allUsers[i]] > 0) {
_voters[_length] = _allUsers[i];
_length++;
}
}
}
}
function readVote(Voting storage _voting, address _voter)
public
view
returns (bool _vote, uint256 _weight)
{
if (_voting.yesVotes[_voter] > 0) {
_weight = _voting.yesVotes[_voter];
_vote = true;
} else {
_weight = _voting.noVotes[_voter]; // if _voter didnt vote at all, the weight will be 0 anyway
_vote = false;
}
}
function revealVote(
Voting storage _voting,
address _voter,
bool _vote,
uint256 _weight
)
public
{
if (_vote) {
_voting.yesVotes[_voter] = _weight;
} else {
_voting.noVotes[_voter] = _weight;
}
}
function readVersion(ProposalVersion storage _version)
public
view
returns (
bytes32 _doc,
uint256 _created,
uint256[] _milestoneFundings,
uint256 _finalReward
)
{
_doc = _version.docIpfsHash;
_created = _version.created;
_milestoneFundings = _version.milestoneFundings;
_finalReward = _version.finalReward;
}
// read the funding for a particular milestone of a finalized proposal
// if _milestoneId is the same as _milestoneCount, it returns the final reward
function readProposalMilestone(Proposal storage _proposal, uint256 _milestoneIndex)
public
view
returns (uint256 _funding)
{
bytes32 _finalVersion = _proposal.finalVersion;
uint256 _milestoneCount = _proposal.proposalVersions[_finalVersion].milestoneFundings.length;
require(_milestoneIndex <= _milestoneCount);
require(_finalVersion != EMPTY_BYTES); // the proposal must have been finalized
if (_milestoneIndex < _milestoneCount) {
_funding = _proposal.proposalVersions[_finalVersion].milestoneFundings[_milestoneIndex];
} else {
_funding = _proposal.proposalVersions[_finalVersion].finalReward;
}
}
function addProposalVersion(
Proposal storage _proposal,
bytes32 _newDoc,
uint256[] _newMilestoneFundings,
uint256 _finalReward
)
public
{
_proposal.proposalVersionDocs.append(_newDoc);
_proposal.proposalVersions[_newDoc].docIpfsHash = _newDoc;
_proposal.proposalVersions[_newDoc].created = now;
_proposal.proposalVersions[_newDoc].milestoneCount = _newMilestoneFundings.length;
_proposal.proposalVersions[_newDoc].milestoneFundings = _newMilestoneFundings;
_proposal.proposalVersions[_newDoc].finalReward = _finalReward;
}
struct SpecialProposal {
// ID of the special proposal
// This is the IPFS doc hash of the proposal
bytes32 proposalId;
// UTC timestamp at which the proposal was created
uint256 timeCreated;
// Voting struct for the special proposal
Voting voting;
// List of the new uint256 configs as per the special proposal
uint256[] uintConfigs;
// List of the new address configs as per the special proposal
address[] addressConfigs;
// List of the new bytes32 configs as per the special proposal
bytes32[] bytesConfigs;
// Address of the user who created the special proposal
// This address should also be in the ROLES_FOUNDERS group
// refer "./../storage/DaoIdentityStorage.sol"
address proposer;
}
// All configs are as per the DaoConfigsStorage values at the time when
// calculateGlobalRewardsBeforeNewQuarter is called by founder in that quarter
struct DaoQuarterInfo {
// The minimum quarter points required
// below this, reputation will be deducted
uint256 minimalParticipationPoint;
// The scaling factor for quarter point
uint256 quarterPointScalingFactor;
// The scaling factor for reputation point
uint256 reputationPointScalingFactor;
// The summation of effectiveDGDs in the previous quarter
// The effectiveDGDs represents the effective participation in DigixDAO in a quarter
// Which depends on lockedDGDStake, quarter point and reputation point
// This value is the summation of all participant effectiveDGDs
// It will be used to calculate the fraction of effectiveDGD a user has,
// which will determine his portion of DGX rewards for that quarter
uint256 totalEffectiveDGDPreviousQuarter;
// The minimum moderator quarter point required
// below this, reputation will be deducted for moderators
uint256 moderatorMinimalParticipationPoint;
// the scaling factor for moderator quarter point
uint256 moderatorQuarterPointScalingFactor;
// the scaling factor for moderator reputation point
uint256 moderatorReputationPointScalingFactor;
// The summation of effectiveDGDs (only specific to moderators)
uint256 totalEffectiveModeratorDGDLastQuarter;
// UTC timestamp from which the DGX rewards for the previous quarter are distributable to Holders
uint256 dgxDistributionDay;
// This is the rewards pool for the previous quarter. This is the sum of the DGX fees coming in from the collector, and the demurrage that has incurred
// when user call claimRewards() in the previous quarter.
// more graphical explanation: https://ipfs.io/ipfs/QmZDgFFMbyF3dvuuDfoXv5F6orq4kaDPo7m3QvnseUguzo
uint256 dgxRewardsPoolLastQuarter;
// The summation of all dgxRewardsPoolLastQuarter up until this quarter
uint256 sumRewardsFromBeginning;
}
// There are many function calls where all calculations/summations cannot be done in one transaction
// and require multiple transactions.
// This struct stores the intermediate results in between the calculating transactions
// These intermediate results are stored in IntermediateResultsStorage
struct IntermediateResults {
// weight of "FOR" votes counted up until the current calculation step
uint256 currentForCount;
// weight of "AGAINST" votes counted up until the current calculation step
uint256 currentAgainstCount;
// summation of effectiveDGDs up until the iteration of calculation
uint256 currentSumOfEffectiveBalance;
// Address of user until which the calculation has been done
address countedUntil;
}
}
// File: contracts/storage/DaoStorage.sol
contract DaoStorage is DaoWhitelistingCommon, BytesIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.Bytes;
using DaoStructs for DaoStructs.Voting;
using DaoStructs for DaoStructs.Proposal;
using DaoStructs for DaoStructs.ProposalVersion;
// List of all the proposals ever created in DigixDAO
DoublyLinkedList.Bytes allProposals;
// mapping of Proposal struct by its ID
// ID is also the IPFS doc hash of the first ever version of this proposal
mapping (bytes32 => DaoStructs.Proposal) proposalsById;
// mapping from state of a proposal to list of all proposals in that state
// proposals are added/removed from the state's list as their states change
// eg. when proposal is endorsed, when proposal is funded, etc
mapping (bytes32 => DoublyLinkedList.Bytes) proposalsByState;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO, _resolver));
}
/////////////////////////////// READ FUNCTIONS //////////////////////////////
/// @notice read all information and details of proposal
/// @param _proposalId Proposal ID, i.e. hash of IPFS doc Proposal ID, i.e. hash of IPFS doc
/// return {
/// "_doc": "Original IPFS doc of proposal, also ID of proposal",
/// "_proposer": "Address of the proposer",
/// "_endorser": "Address of the moderator that endorsed the proposal",
/// "_state": "Current state of the proposal",
/// "_timeCreated": "UTC timestamp at which proposal was created",
/// "_nVersions": "Number of versions of the proposal",
/// "_latestVersionDoc": "IPFS doc hash of the latest version of this proposal",
/// "_finalVersion": "If finalized, the version of the final proposal",
/// "_pausedOrStopped": "If the proposal is paused/stopped at the moment",
/// "_isDigixProposal": "If the proposal has been created by founder or not"
/// }
function readProposal(bytes32 _proposalId)
public
view
returns (
bytes32 _doc,
address _proposer,
address _endorser,
bytes32 _state,
uint256 _timeCreated,
uint256 _nVersions,
bytes32 _latestVersionDoc,
bytes32 _finalVersion,
bool _pausedOrStopped,
bool _isDigixProposal
)
{
require(senderIsAllowedToRead());
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_doc = _proposal.proposalId;
_proposer = _proposal.proposer;
_endorser = _proposal.endorser;
_state = _proposal.currentState;
_timeCreated = _proposal.timeCreated;
_nVersions = read_total_bytesarray(_proposal.proposalVersionDocs);
_latestVersionDoc = read_last_from_bytesarray(_proposal.proposalVersionDocs);
_finalVersion = _proposal.finalVersion;
_pausedOrStopped = _proposal.isPausedOrStopped;
_isDigixProposal = _proposal.isDigix;
}
function readProposalProposer(bytes32 _proposalId)
public
view
returns (address _proposer)
{
_proposer = proposalsById[_proposalId].proposer;
}
function readTotalPrlActions(bytes32 _proposalId)
public
view
returns (uint256 _length)
{
_length = proposalsById[_proposalId].prlActions.length;
}
function readPrlAction(bytes32 _proposalId, uint256 _index)
public
view
returns (uint256 _actionId, uint256 _time, bytes32 _doc)
{
DaoStructs.PrlAction[] memory _actions = proposalsById[_proposalId].prlActions;
require(_index < _actions.length);
_actionId = _actions[_index].actionId;
_time = _actions[_index].at;
_doc = _actions[_index].doc;
}
function readProposalDraftVotingResult(bytes32 _proposalId)
public
view
returns (bool _result)
{
require(senderIsAllowedToRead());
_result = proposalsById[_proposalId].draftVoting.passed;
}
function readProposalVotingResult(bytes32 _proposalId, uint256 _index)
public
view
returns (bool _result)
{
require(senderIsAllowedToRead());
_result = proposalsById[_proposalId].votingRounds[_index].passed;
}
function readProposalDraftVotingTime(bytes32 _proposalId)
public
view
returns (uint256 _start)
{
require(senderIsAllowedToRead());
_start = proposalsById[_proposalId].draftVoting.startTime;
}
function readProposalVotingTime(bytes32 _proposalId, uint256 _index)
public
view
returns (uint256 _start)
{
require(senderIsAllowedToRead());
_start = proposalsById[_proposalId].votingRounds[_index].startTime;
}
function readDraftVotingCount(bytes32 _proposalId, address[] _allUsers)
external
view
returns (uint256 _for, uint256 _against)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].draftVoting.countVotes(_allUsers);
}
function readVotingCount(bytes32 _proposalId, uint256 _index, address[] _allUsers)
external
view
returns (uint256 _for, uint256 _against)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].votingRounds[_index].countVotes(_allUsers);
}
function readVotingRoundVotes(bytes32 _proposalId, uint256 _index, address[] _allUsers, bool _vote)
external
view
returns (address[] memory _voters, uint256 _length)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].votingRounds[_index].listVotes(_allUsers, _vote);
}
function readDraftVote(bytes32 _proposalId, address _voter)
public
view
returns (bool _vote, uint256 _weight)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].draftVoting.readVote(_voter);
}
/// @notice returns the latest committed vote by a voter on a proposal
/// @param _proposalId proposal ID
/// @param _voter address of the voter
/// @return {
/// "_commitHash": ""
/// }
function readComittedVote(bytes32 _proposalId, uint256 _index, address _voter)
public
view
returns (bytes32 _commitHash)
{
require(senderIsAllowedToRead());
_commitHash = proposalsById[_proposalId].votingRounds[_index].commits[_voter];
}
function readVote(bytes32 _proposalId, uint256 _index, address _voter)
public
view
returns (bool _vote, uint256 _weight)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].votingRounds[_index].readVote(_voter);
}
/// @notice get all information and details of the first proposal
/// return {
/// "_id": ""
/// }
function getFirstProposal()
public
view
returns (bytes32 _id)
{
_id = read_first_from_bytesarray(allProposals);
}
/// @notice get all information and details of the last proposal
/// return {
/// "_id": ""
/// }
function getLastProposal()
public
view
returns (bytes32 _id)
{
_id = read_last_from_bytesarray(allProposals);
}
/// @notice get all information and details of proposal next to _proposalId
/// @param _proposalId Proposal ID, i.e. hash of IPFS doc
/// return {
/// "_id": ""
/// }
function getNextProposal(bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
_id = read_next_from_bytesarray(
allProposals,
_proposalId
);
}
/// @notice get all information and details of proposal previous to _proposalId
/// @param _proposalId Proposal ID, i.e. hash of IPFS doc
/// return {
/// "_id": ""
/// }
function getPreviousProposal(bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
_id = read_previous_from_bytesarray(
allProposals,
_proposalId
);
}
/// @notice get all information and details of the first proposal in state _stateId
/// @param _stateId State ID of the proposal
/// return {
/// "_id": ""
/// }
function getFirstProposalInState(bytes32 _stateId)
public
view
returns (bytes32 _id)
{
require(senderIsAllowedToRead());
_id = read_first_from_bytesarray(proposalsByState[_stateId]);
}
/// @notice get all information and details of the last proposal in state _stateId
/// @param _stateId State ID of the proposal
/// return {
/// "_id": ""
/// }
function getLastProposalInState(bytes32 _stateId)
public
view
returns (bytes32 _id)
{
require(senderIsAllowedToRead());
_id = read_last_from_bytesarray(proposalsByState[_stateId]);
}
/// @notice get all information and details of the next proposal to _proposalId in state _stateId
/// @param _stateId State ID of the proposal
/// return {
/// "_id": ""
/// }
function getNextProposalInState(bytes32 _stateId, bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
require(senderIsAllowedToRead());
_id = read_next_from_bytesarray(
proposalsByState[_stateId],
_proposalId
);
}
/// @notice get all information and details of the previous proposal to _proposalId in state _stateId
/// @param _stateId State ID of the proposal
/// return {
/// "_id": ""
/// }
function getPreviousProposalInState(bytes32 _stateId, bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
require(senderIsAllowedToRead());
_id = read_previous_from_bytesarray(
proposalsByState[_stateId],
_proposalId
);
}
/// @notice read proposal version details for a specific version
/// @param _proposalId Proposal ID, i.e. hash of IPFS doc
/// @param _version Version of proposal, i.e. hash of IPFS doc for specific version
/// return {
/// "_doc": "",
/// "_created": "",
/// "_milestoneFundings": ""
/// }
function readProposalVersion(bytes32 _proposalId, bytes32 _version)
public
view
returns (
bytes32 _doc,
uint256 _created,
uint256[] _milestoneFundings,
uint256 _finalReward
)
{
return proposalsById[_proposalId].proposalVersions[_version].readVersion();
}
/**
@notice Read the fundings of a finalized proposal
@return {
"_fundings": "fundings for the milestones",
"_finalReward": "the final reward"
}
*/
function readProposalFunding(bytes32 _proposalId)
public
view
returns (uint256[] memory _fundings, uint256 _finalReward)
{
require(senderIsAllowedToRead());
bytes32 _finalVersion = proposalsById[_proposalId].finalVersion;
require(_finalVersion != EMPTY_BYTES);
_fundings = proposalsById[_proposalId].proposalVersions[_finalVersion].milestoneFundings;
_finalReward = proposalsById[_proposalId].proposalVersions[_finalVersion].finalReward;
}
function readProposalMilestone(bytes32 _proposalId, uint256 _index)
public
view
returns (uint256 _funding)
{
require(senderIsAllowedToRead());
_funding = proposalsById[_proposalId].readProposalMilestone(_index);
}
/// @notice get proposal version details for the first version
/// @param _proposalId Proposal ID, i.e. hash of IPFS doc
/// return {
/// "_version": ""
/// }
function getFirstProposalVersion(bytes32 _proposalId)
public
view
returns (bytes32 _version)
{
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_version = read_first_from_bytesarray(_proposal.proposalVersionDocs);
}
/// @notice get proposal version details for the last version
/// @param _proposalId Proposal ID, i.e. hash of IPFS doc
/// return {
/// "_version": ""
/// }
function getLastProposalVersion(bytes32 _proposalId)
public
view
returns (bytes32 _version)
{
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_version = read_last_from_bytesarray(_proposal.proposalVersionDocs);
}
/// @notice get proposal version details for the next version to _version
/// @param _proposalId Proposal ID, i.e. hash of IPFS doc
/// @param _version Version of proposal
/// return {
/// "_nextVersion": ""
/// }
function getNextProposalVersion(bytes32 _proposalId, bytes32 _version)
public
view
returns (bytes32 _nextVersion)
{
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_nextVersion = read_next_from_bytesarray(
_proposal.proposalVersionDocs,
_version
);
}
/// @notice get proposal version details for the previous version to _version
/// @param _proposalId Proposal ID, i.e. hash of IPFS doc
/// @param _version Version of proposal
/// return {
/// "_previousVersion": ""
/// }
function getPreviousProposalVersion(bytes32 _proposalId, bytes32 _version)
public
view
returns (bytes32 _previousVersion)
{
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_previousVersion = read_previous_from_bytesarray(
_proposal.proposalVersionDocs,
_version
);
}
function isDraftClaimed(bytes32 _proposalId)
public
view
returns (bool _claimed)
{
_claimed = proposalsById[_proposalId].draftVoting.claimed;
}
function isClaimed(bytes32 _proposalId, uint256 _index)
public
view
returns (bool _claimed)
{
_claimed = proposalsById[_proposalId].votingRounds[_index].claimed;
}
function readProposalCollateralStatus(bytes32 _proposalId)
public
view
returns (uint256 _status)
{
require(senderIsAllowedToRead());
_status = proposalsById[_proposalId].collateralStatus;
}
function readProposalCollateralAmount(bytes32 _proposalId)
public
view
returns (uint256 _amount)
{
_amount = proposalsById[_proposalId].collateralAmount;
}
/// @notice Read the additional docs that are added after the proposal is finalized
/// @dev Will throw if the propsal is not finalized yet
function readProposalDocs(bytes32 _proposalId)
public
view
returns (bytes32[] _moreDocs)
{
bytes32 _finalVersion = proposalsById[_proposalId].finalVersion;
require(_finalVersion != EMPTY_BYTES);
_moreDocs = proposalsById[_proposalId].proposalVersions[_finalVersion].moreDocs;
}
function readIfMilestoneFunded(bytes32 _proposalId, uint256 _milestoneId)
public
view
returns (bool _funded)
{
require(senderIsAllowedToRead());
_funded = proposalsById[_proposalId].votingRounds[_milestoneId].funded;
}
////////////////////////////// WRITE FUNCTIONS //////////////////////////////
function addProposal(
bytes32 _doc,
address _proposer,
uint256[] _milestoneFundings,
uint256 _finalReward,
bool _isFounder
)
external
{
require(sender_is(CONTRACT_DAO));
require(
(proposalsById[_doc].proposalId == EMPTY_BYTES) &&
(_doc != EMPTY_BYTES)
);
allProposals.append(_doc);
proposalsByState[PROPOSAL_STATE_PREPROPOSAL].append(_doc);
proposalsById[_doc].proposalId = _doc;
proposalsById[_doc].proposer = _proposer;
proposalsById[_doc].currentState = PROPOSAL_STATE_PREPROPOSAL;
proposalsById[_doc].timeCreated = now;
proposalsById[_doc].isDigix = _isFounder;
proposalsById[_doc].addProposalVersion(_doc, _milestoneFundings, _finalReward);
}
function editProposal(
bytes32 _proposalId,
bytes32 _newDoc,
uint256[] _newMilestoneFundings,
uint256 _finalReward
)
external
{
require(sender_is(CONTRACT_DAO));
proposalsById[_proposalId].addProposalVersion(_newDoc, _newMilestoneFundings, _finalReward);
}
/// @notice change fundings of a proposal
/// @dev Will throw if the proposal is not finalized yet
function changeFundings(bytes32 _proposalId, uint256[] _newMilestoneFundings, uint256 _finalReward)
external
{
require(sender_is(CONTRACT_DAO));
bytes32 _finalVersion = proposalsById[_proposalId].finalVersion;
require(_finalVersion != EMPTY_BYTES);
proposalsById[_proposalId].proposalVersions[_finalVersion].milestoneFundings = _newMilestoneFundings;
proposalsById[_proposalId].proposalVersions[_finalVersion].finalReward = _finalReward;
}
/// @dev Will throw if the proposal is not finalized yet
function addProposalDoc(bytes32 _proposalId, bytes32 _newDoc)
public
{
require(sender_is(CONTRACT_DAO));
bytes32 _finalVersion = proposalsById[_proposalId].finalVersion;
require(_finalVersion != EMPTY_BYTES); //already checked in interactive layer, but why not
proposalsById[_proposalId].proposalVersions[_finalVersion].moreDocs.push(_newDoc);
}
function finalizeProposal(bytes32 _proposalId)
public
{
require(sender_is(CONTRACT_DAO));
proposalsById[_proposalId].finalVersion = getLastProposalVersion(_proposalId);
}
function updateProposalEndorse(
bytes32 _proposalId,
address _endorser
)
public
{
require(sender_is(CONTRACT_DAO));
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_proposal.endorser = _endorser;
_proposal.currentState = PROPOSAL_STATE_DRAFT;
proposalsByState[PROPOSAL_STATE_PREPROPOSAL].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_DRAFT].append(_proposalId);
}
function setProposalDraftPass(bytes32 _proposalId, bool _result)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].draftVoting.passed = _result;
if (_result) {
proposalsByState[PROPOSAL_STATE_DRAFT].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_MODERATED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_MODERATED;
} else {
closeProposalInternal(_proposalId);
}
}
function setProposalPass(bytes32 _proposalId, uint256 _index, bool _result)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
if (!_result) {
closeProposalInternal(_proposalId);
} else if (_index == 0) {
proposalsByState[PROPOSAL_STATE_MODERATED].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_ONGOING].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_ONGOING;
}
proposalsById[_proposalId].votingRounds[_index].passed = _result;
}
function setProposalDraftVotingTime(
bytes32 _proposalId,
uint256 _time
)
public
{
require(sender_is(CONTRACT_DAO));
proposalsById[_proposalId].draftVoting.startTime = _time;
}
function setProposalVotingTime(
bytes32 _proposalId,
uint256 _index,
uint256 _time
)
public
{
require(sender_is_from([CONTRACT_DAO, CONTRACT_DAO_VOTING_CLAIMS, EMPTY_BYTES]));
proposalsById[_proposalId].votingRounds[_index].startTime = _time;
}
function setDraftVotingClaim(bytes32 _proposalId, bool _claimed)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].draftVoting.claimed = _claimed;
}
function setVotingClaim(bytes32 _proposalId, uint256 _index, bool _claimed)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].votingRounds[_index].claimed = _claimed;
}
function setProposalCollateralStatus(bytes32 _proposalId, uint256 _status)
public
{
require(sender_is_from([CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_FUNDING_MANAGER, CONTRACT_DAO]));
proposalsById[_proposalId].collateralStatus = _status;
}
function setProposalCollateralAmount(bytes32 _proposalId, uint256 _amount)
public
{
require(sender_is(CONTRACT_DAO));
proposalsById[_proposalId].collateralAmount = _amount;
}
function updateProposalPRL(
bytes32 _proposalId,
uint256 _action,
bytes32 _doc,
uint256 _time
)
public
{
require(sender_is(CONTRACT_DAO));
require(proposalsById[_proposalId].currentState != PROPOSAL_STATE_CLOSED);
DaoStructs.PrlAction memory prlAction;
prlAction.at = _time;
prlAction.doc = _doc;
prlAction.actionId = _action;
proposalsById[_proposalId].prlActions.push(prlAction);
if (_action == PRL_ACTION_PAUSE) {
proposalsById[_proposalId].isPausedOrStopped = true;
} else if (_action == PRL_ACTION_UNPAUSE) {
proposalsById[_proposalId].isPausedOrStopped = false;
} else { // STOP
proposalsById[_proposalId].isPausedOrStopped = true;
closeProposalInternal(_proposalId);
}
}
function closeProposalInternal(bytes32 _proposalId)
internal
{
bytes32 _currentState = proposalsById[_proposalId].currentState;
proposalsByState[_currentState].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_CLOSED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_CLOSED;
}
function addDraftVote(
bytes32 _proposalId,
address _voter,
bool _vote,
uint256 _weight
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
if (_vote) {
_proposal.draftVoting.yesVotes[_voter] = _weight;
if (_proposal.draftVoting.noVotes[_voter] > 0) { // minimize number of writes to storage, since EIP-1087 is not implemented yet
_proposal.draftVoting.noVotes[_voter] = 0;
}
} else {
_proposal.draftVoting.noVotes[_voter] = _weight;
if (_proposal.draftVoting.yesVotes[_voter] > 0) {
_proposal.draftVoting.yesVotes[_voter] = 0;
}
}
}
function commitVote(
bytes32 _proposalId,
bytes32 _hash,
address _voter,
uint256 _index
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].votingRounds[_index].commits[_voter] = _hash;
}
function revealVote(
bytes32 _proposalId,
address _voter,
bool _vote,
uint256 _weight,
uint256 _index
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].votingRounds[_index].revealVote(_voter, _vote, _weight);
}
function closeProposal(bytes32 _proposalId)
public
{
require(sender_is(CONTRACT_DAO));
closeProposalInternal(_proposalId);
}
function archiveProposal(bytes32 _proposalId)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
bytes32 _currentState = proposalsById[_proposalId].currentState;
proposalsByState[_currentState].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_ARCHIVED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_ARCHIVED;
}
function setMilestoneFunded(bytes32 _proposalId, uint256 _milestoneId)
public
{
require(sender_is(CONTRACT_DAO_FUNDING_MANAGER));
proposalsById[_proposalId].votingRounds[_milestoneId].funded = true;
}
}
// File: @digix/solidity-collections/contracts/abstract/AddressIteratorStorage.sol
/**
@title Address Iterator Storage
@author DigixGlobal Pte Ltd
@notice See: [Doubly Linked List](/DoublyLinkedList)
*/
contract AddressIteratorStorage {
// Initialize Doubly Linked List of Address
using DoublyLinkedList for DoublyLinkedList.Address;
/**
@notice Reads the first item from the list of Address
@param _list The source list
@return {"_item" : "The first item from the list"}
*/
function read_first_from_addresses(DoublyLinkedList.Address storage _list)
internal
constant
returns (address _item)
{
_item = _list.start_item();
}
/**
@notice Reads the last item from the list of Address
@param _list The source list
@return {"_item" : "The last item from the list"}
*/
function read_last_from_addresses(DoublyLinkedList.Address storage _list)
internal
constant
returns (address _item)
{
_item = _list.end_item();
}
/**
@notice Reads the next item on the list of Address
@param _list The source list
@param _current_item The current item to be used as base line
@return {"_item" : "The next item from the list based on the specieid `_current_item`"}
*/
function read_next_from_addresses(DoublyLinkedList.Address storage _list, address _current_item)
internal
constant
returns (address _item)
{
_item = _list.next_item(_current_item);
}
/**
@notice Reads the previous item on the list of Address
@param _list The source list
@param _current_item The current item to be used as base line
@return {"_item" : "The previous item from the list based on the spcified `_current_item`"}
*/
function read_previous_from_addresses(DoublyLinkedList.Address storage _list, address _current_item)
internal
constant
returns (address _item)
{
_item = _list.previous_item(_current_item);
}
/**
@notice Reads the list of Address and returns the length of the list
@param _list The source list
@return {"_count": "The lenght of the list"}
*/
function read_total_addresses(DoublyLinkedList.Address storage _list)
internal
constant
returns (uint256 _count)
{
_count = _list.total();
}
}
// File: contracts/storage/DaoStakeStorage.sol
contract DaoStakeStorage is ResolverClient, DaoConstants, AddressIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.Address;
// This is the DGD stake of a user (one that is considered in the DAO)
mapping (address => uint256) public lockedDGDStake;
// This is the actual number of DGDs locked by user
// may be more than the lockedDGDStake
// in case they locked during the main phase
mapping (address => uint256) public actualLockedDGD;
// The total locked DGDs in the DAO (summation of lockedDGDStake)
uint256 public totalLockedDGDStake;
// The total locked DGDs by moderators
uint256 public totalModeratorLockedDGDStake;
// The list of participants in DAO
// actual participants will be subset of this list
DoublyLinkedList.Address allParticipants;
// The list of moderators in DAO
// actual moderators will be subset of this list
DoublyLinkedList.Address allModerators;
// Boolean to mark if an address has redeemed
// reputation points for their DGD Badge
mapping (address => bool) public redeemedBadge;
// mapping to note whether an address has claimed their
// reputation bonus for carbon vote participation
mapping (address => bool) public carbonVoteBonusClaimed;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO_STAKE, _resolver));
}
function redeemBadge(address _user)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
redeemedBadge[_user] = true;
}
function setCarbonVoteBonusClaimed(address _user)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
carbonVoteBonusClaimed[_user] = true;
}
function updateTotalLockedDGDStake(uint256 _totalLockedDGDStake)
public
{
require(sender_is_from([CONTRACT_DAO_STAKE_LOCKING, CONTRACT_DAO_REWARDS_MANAGER, EMPTY_BYTES]));
totalLockedDGDStake = _totalLockedDGDStake;
}
function updateTotalModeratorLockedDGDs(uint256 _totalLockedDGDStake)
public
{
require(sender_is_from([CONTRACT_DAO_STAKE_LOCKING, CONTRACT_DAO_REWARDS_MANAGER, EMPTY_BYTES]));
totalModeratorLockedDGDStake = _totalLockedDGDStake;
}
function updateUserDGDStake(address _user, uint256 _actualLockedDGD, uint256 _lockedDGDStake)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
actualLockedDGD[_user] = _actualLockedDGD;
lockedDGDStake[_user] = _lockedDGDStake;
}
function readUserDGDStake(address _user)
public
view
returns (
uint256 _actualLockedDGD,
uint256 _lockedDGDStake
)
{
_actualLockedDGD = actualLockedDGD[_user];
_lockedDGDStake = lockedDGDStake[_user];
}
function addToParticipantList(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
_success = allParticipants.append(_user);
}
function removeFromParticipantList(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
_success = allParticipants.remove_item(_user);
}
function addToModeratorList(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
_success = allModerators.append(_user);
}
function removeFromModeratorList(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
_success = allModerators.remove_item(_user);
}
function isInParticipantList(address _user)
public
view
returns (bool _is)
{
_is = allParticipants.find(_user) != 0;
}
function isInModeratorsList(address _user)
public
view
returns (bool _is)
{
_is = allModerators.find(_user) != 0;
}
function readFirstModerator()
public
view
returns (address _item)
{
_item = read_first_from_addresses(allModerators);
}
function readLastModerator()
public
view
returns (address _item)
{
_item = read_last_from_addresses(allModerators);
}
function readNextModerator(address _current_item)
public
view
returns (address _item)
{
_item = read_next_from_addresses(allModerators, _current_item);
}
function readPreviousModerator(address _current_item)
public
view
returns (address _item)
{
_item = read_previous_from_addresses(allModerators, _current_item);
}
function readTotalModerators()
public
view
returns (uint256 _total_count)
{
_total_count = read_total_addresses(allModerators);
}
function readFirstParticipant()
public
view
returns (address _item)
{
_item = read_first_from_addresses(allParticipants);
}
function readLastParticipant()
public
view
returns (address _item)
{
_item = read_last_from_addresses(allParticipants);
}
function readNextParticipant(address _current_item)
public
view
returns (address _item)
{
_item = read_next_from_addresses(allParticipants, _current_item);
}
function readPreviousParticipant(address _current_item)
public
view
returns (address _item)
{
_item = read_previous_from_addresses(allParticipants, _current_item);
}
function readTotalParticipant()
public
view
returns (uint256 _total_count)
{
_total_count = read_total_addresses(allParticipants);
}
}
// File: contracts/service/DaoListingService.sol
/* import "@digix/cacp-contracts-dao/contracts/ResolverClient.sol"; */
/**
@title Contract to list various storage states from DigixDAO
@author Digix Holdings
*/
contract DaoListingService is
AddressIteratorInteractive,
BytesIteratorInteractive,
IndexedBytesIteratorInteractive,
DaoWhitelistingCommon
{
/**
@notice Constructor
@param _resolver address of contract resolver
*/
constructor(address _resolver) public {
require(init(CONTRACT_SERVICE_DAO_LISTING, _resolver));
}
function daoStakeStorage()
internal
view
returns (DaoStakeStorage _contract)
{
_contract = DaoStakeStorage(get_contract(CONTRACT_STORAGE_DAO_STAKE));
}
function daoStorage()
internal
view
returns (DaoStorage _contract)
{
_contract = DaoStorage(get_contract(CONTRACT_STORAGE_DAO));
}
/**
@notice function to list moderators
@dev note that this list may include some additional entries that are
not moderators in the current quarter. This may happen if they
were moderators in the previous quarter, but have not confirmed
their participation in the current quarter. For a single address,
a better way to know if moderator or not is:
Dao.isModerator(_user)
@param _count number of addresses to list
@param _from_start boolean, whether to list from start or end
@return {
"_moderators": "list of moderator addresses"
}
*/
function listModerators(uint256 _count, bool _from_start)
public
view
returns (address[] _moderators)
{
_moderators = list_addresses(
_count,
daoStakeStorage().readFirstModerator,
daoStakeStorage().readLastModerator,
daoStakeStorage().readNextModerator,
daoStakeStorage().readPreviousModerator,
_from_start
);
}
/**
@notice function to list moderators from a particular moderator
@dev note that this list may include some additional entries that are
not moderators in the current quarter. This may happen if they
were moderators in the previous quarter, but have not confirmed
their participation in the current quarter. For a single address,
a better way to know if moderator or not is:
Dao.isModerator(_user)
Another note: this function will start listing AFTER the _currentModerator
For example: we have [address1, address2, address3, address4]. listModeratorsFrom(address1, 2, true) = [address2, address3]
@param _currentModerator start the list after this moderator address
@param _count number of addresses to list
@param _from_start boolean, whether to list from start or end
@return {
"_moderators": "list of moderator addresses"
}
*/
function listModeratorsFrom(
address _currentModerator,
uint256 _count,
bool _from_start
)
public
view
returns (address[] _moderators)
{
_moderators = list_addresses_from(
_currentModerator,
_count,
daoStakeStorage().readFirstModerator,
daoStakeStorage().readLastModerator,
daoStakeStorage().readNextModerator,
daoStakeStorage().readPreviousModerator,
_from_start
);
}
/**
@notice function to list participants
@dev note that this list may include some additional entries that are
not participants in the current quarter. This may happen if they
were participants in the previous quarter, but have not confirmed
their participation in the current quarter. For a single address,
a better way to know if participant or not is:
Dao.isParticipant(_user)
@param _count number of addresses to list
@param _from_start boolean, whether to list from start or end
@return {
"_participants": "list of participant addresses"
}
*/
function listParticipants(uint256 _count, bool _from_start)
public
view
returns (address[] _participants)
{
_participants = list_addresses(
_count,
daoStakeStorage().readFirstParticipant,
daoStakeStorage().readLastParticipant,
daoStakeStorage().readNextParticipant,
daoStakeStorage().readPreviousParticipant,
_from_start
);
}
/**
@notice function to list participants from a particular participant
@dev note that this list may include some additional entries that are
not participants in the current quarter. This may happen if they
were participants in the previous quarter, but have not confirmed
their participation in the current quarter. For a single address,
a better way to know if participant or not is:
contracts.dao.isParticipant(_user)
Another note: this function will start listing AFTER the _currentParticipant
For example: we have [address1, address2, address3, address4]. listParticipantsFrom(address1, 2, true) = [address2, address3]
@param _currentParticipant list from AFTER this participant address
@param _count number of addresses to list
@param _from_start boolean, whether to list from start or end
@return {
"_participants": "list of participant addresses"
}
*/
function listParticipantsFrom(
address _currentParticipant,
uint256 _count,
bool _from_start
)
public
view
returns (address[] _participants)
{
_participants = list_addresses_from(
_currentParticipant,
_count,
daoStakeStorage().readFirstParticipant,
daoStakeStorage().readLastParticipant,
daoStakeStorage().readNextParticipant,
daoStakeStorage().readPreviousParticipant,
_from_start
);
}
/**
@notice function to list _count no. of proposals
@param _count number of proposals to list
@param _from_start boolean value, true if count from start, false if count from end
@return {
"_proposals": "the list of proposal IDs"
}
*/
function listProposals(
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _proposals)
{
_proposals = list_bytesarray(
_count,
daoStorage().getFirstProposal,
daoStorage().getLastProposal,
daoStorage().getNextProposal,
daoStorage().getPreviousProposal,
_from_start
);
}
/**
@notice function to list _count no. of proposals from AFTER _currentProposal
@param _currentProposal ID of proposal to list proposals from
@param _count number of proposals to list
@param _from_start boolean value, true if count forwards, false if count backwards
@return {
"_proposals": "the list of proposal IDs"
}
*/
function listProposalsFrom(
bytes32 _currentProposal,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _proposals)
{
_proposals = list_bytesarray_from(
_currentProposal,
_count,
daoStorage().getFirstProposal,
daoStorage().getLastProposal,
daoStorage().getNextProposal,
daoStorage().getPreviousProposal,
_from_start
);
}
/**
@notice function to list _count no. of proposals in state _stateId
@param _stateId state of proposal
@param _count number of proposals to list
@param _from_start boolean value, true if count from start, false if count from end
@return {
"_proposals": "the list of proposal IDs"
}
*/
function listProposalsInState(
bytes32 _stateId,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _proposals)
{
require(senderIsAllowedToRead());
_proposals = list_indexed_bytesarray(
_stateId,
_count,
daoStorage().getFirstProposalInState,
daoStorage().getLastProposalInState,
daoStorage().getNextProposalInState,
daoStorage().getPreviousProposalInState,
_from_start
);
}
/**
@notice function to list _count no. of proposals in state _stateId from AFTER _currentProposal
@param _stateId state of proposal
@param _currentProposal ID of proposal to list proposals from
@param _count number of proposals to list
@param _from_start boolean value, true if count forwards, false if count backwards
@return {
"_proposals": "the list of proposal IDs"
}
*/
function listProposalsInStateFrom(
bytes32 _stateId,
bytes32 _currentProposal,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _proposals)
{
require(senderIsAllowedToRead());
_proposals = list_indexed_bytesarray_from(
_stateId,
_currentProposal,
_count,
daoStorage().getFirstProposalInState,
daoStorage().getLastProposalInState,
daoStorage().getNextProposalInState,
daoStorage().getPreviousProposalInState,
_from_start
);
}
/**
@notice function to list proposal versions
@param _proposalId ID of the proposal
@param _count number of proposal versions to list
@param _from_start boolean, true to list from start, false to list from end
@return {
"_versions": "list of proposal versions"
}
*/
function listProposalVersions(
bytes32 _proposalId,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _versions)
{
_versions = list_indexed_bytesarray(
_proposalId,
_count,
daoStorage().getFirstProposalVersion,
daoStorage().getLastProposalVersion,
daoStorage().getNextProposalVersion,
daoStorage().getPreviousProposalVersion,
_from_start
);
}
/**
@notice function to list proposal versions from AFTER a particular version
@param _proposalId ID of the proposal
@param _currentVersion version to list _count versions from
@param _count number of proposal versions to list
@param _from_start boolean, true to list from start, false to list from end
@return {
"_versions": "list of proposal versions"
}
*/
function listProposalVersionsFrom(
bytes32 _proposalId,
bytes32 _currentVersion,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _versions)
{
_versions = list_indexed_bytesarray_from(
_proposalId,
_currentVersion,
_count,
daoStorage().getFirstProposalVersion,
daoStorage().getLastProposalVersion,
daoStorage().getNextProposalVersion,
daoStorage().getPreviousProposalVersion,
_from_start
);
}
}
// File: @digix/solidity-collections/contracts/abstract/IndexedAddressIteratorStorage.sol
/**
@title Indexed Address IteratorStorage
@author DigixGlobal Pte Ltd
@notice This contract utilizes: [Doubly Linked List](/DoublyLinkedList)
*/
contract IndexedAddressIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.IndexedAddress;
/**
@notice Reads the first item from an Indexed Address Doubly Linked List
@param _list The source list
@param _collection_index Index of the Collection to evaluate
@return {"_item" : "First item on the list"}
*/
function read_first_from_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index)
internal
constant
returns (address _item)
{
_item = _list.start_item(_collection_index);
}
/**
@notice Reads the last item from an Indexed Address Doubly Linked list
@param _list The source list
@param _collection_index Index of the Collection to evaluate
@return {"_item" : "First item on the list"}
*/
function read_last_from_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index)
internal
constant
returns (address _item)
{
_item = _list.end_item(_collection_index);
}
/**
@notice Reads the next item from an Indexed Address Doubly Linked List based on the specified `_current_item`
@param _list The source list
@param _collection_index Index of the Collection to evaluate
@param _current_item The current item to use as base line
@return {"_item": "The next item on the list"}
*/
function read_next_from_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index, address _current_item)
internal
constant
returns (address _item)
{
_item = _list.next_item(_collection_index, _current_item);
}
/**
@notice Reads the previous item from an Index Address Doubly Linked List based on the specified `_current_item`
@param _list The source list
@param _collection_index Index of the Collection to evaluate
@param _current_item The current item to use as base line
@return {"_item" : "The previous item on the list"}
*/
function read_previous_from_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index, address _current_item)
internal
constant
returns (address _item)
{
_item = _list.previous_item(_collection_index, _current_item);
}
/**
@notice Reads the total number of items in an Indexed Address Doubly Linked List
@param _list The source list
@param _collection_index Index of the Collection to evaluate
@return {"_count": "Length of the Doubly Linked list"}
*/
function read_total_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index)
internal
constant
returns (uint256 _count)
{
_count = _list.total(_collection_index);
}
}
// File: @digix/solidity-collections/contracts/abstract/UintIteratorStorage.sol
/**
@title Uint Iterator Storage
@author DigixGlobal Pte Ltd
*/
contract UintIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.Uint;
/**
@notice Returns the first item from a `DoublyLinkedList.Uint` list
@param _list The DoublyLinkedList.Uint list
@return {"_item": "The first item"}
*/
function read_first_from_uints(DoublyLinkedList.Uint storage _list)
internal
constant
returns (uint256 _item)
{
_item = _list.start_item();
}
/**
@notice Returns the last item from a `DoublyLinkedList.Uint` list
@param _list The DoublyLinkedList.Uint list
@return {"_item": "The last item"}
*/
function read_last_from_uints(DoublyLinkedList.Uint storage _list)
internal
constant
returns (uint256 _item)
{
_item = _list.end_item();
}
/**
@notice Returns the next item from a `DoublyLinkedList.Uint` list based on the specified `_current_item`
@param _list The DoublyLinkedList.Uint list
@param _current_item The current item
@return {"_item": "The next item"}
*/
function read_next_from_uints(DoublyLinkedList.Uint storage _list, uint256 _current_item)
internal
constant
returns (uint256 _item)
{
_item = _list.next_item(_current_item);
}
/**
@notice Returns the previous item from a `DoublyLinkedList.Uint` list based on the specified `_current_item`
@param _list The DoublyLinkedList.Uint list
@param _current_item The current item
@return {"_item": "The previous item"}
*/
function read_previous_from_uints(DoublyLinkedList.Uint storage _list, uint256 _current_item)
internal
constant
returns (uint256 _item)
{
_item = _list.previous_item(_current_item);
}
/**
@notice Returns the total count of itemsfrom a `DoublyLinkedList.Uint` list
@param _list The DoublyLinkedList.Uint list
@return {"_count": "The total count of items"}
*/
function read_total_uints(DoublyLinkedList.Uint storage _list)
internal
constant
returns (uint256 _count)
{
_count = _list.total();
}
}
// File: @digix/cdap/contracts/storage/DirectoryStorage.sol
/**
@title Directory Storage contains information of a directory
@author DigixGlobal
*/
contract DirectoryStorage is IndexedAddressIteratorStorage, UintIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.IndexedAddress;
using DoublyLinkedList for DoublyLinkedList.Uint;
struct User {
bytes32 document;
bool active;
}
struct Group {
bytes32 name;
bytes32 document;
uint256 role_id;
mapping(address => User) members_by_address;
}
struct System {
DoublyLinkedList.Uint groups;
DoublyLinkedList.IndexedAddress groups_collection;
mapping (uint256 => Group) groups_by_id;
mapping (address => uint256) group_ids_by_address;
mapping (uint256 => bytes32) roles_by_id;
bool initialized;
uint256 total_groups;
}
System system;
/**
@notice Initializes directory settings
@return _success If directory initialization is successful
*/
function initialize_directory()
internal
returns (bool _success)
{
require(system.initialized == false);
system.total_groups = 0;
system.initialized = true;
internal_create_role(1, "root");
internal_create_group(1, "root", "");
_success = internal_update_add_user_to_group(1, tx.origin, "");
}
/**
@notice Creates a new role with the given information
@param _role_id Id of the new role
@param _name Name of the new role
@return {"_success": "If creation of new role is successful"}
*/
function internal_create_role(uint256 _role_id, bytes32 _name)
internal
returns (bool _success)
{
require(_role_id > 0);
require(_name != bytes32(0x0));
system.roles_by_id[_role_id] = _name;
_success = true;
}
/**
@notice Returns the role's name of a role id
@param _role_id Id of the role
@return {"_name": "Name of the role"}
*/
function read_role(uint256 _role_id)
public
constant
returns (bytes32 _name)
{
_name = system.roles_by_id[_role_id];
}
/**
@notice Creates a new group with the given information
@param _role_id Role id of the new group
@param _name Name of the new group
@param _document Document of the new group
@return {
"_success": "If creation of the new group is successful",
"_group_id: "Id of the new group"
}
*/
function internal_create_group(uint256 _role_id, bytes32 _name, bytes32 _document)
internal
returns (bool _success, uint256 _group_id)
{
require(_role_id > 0);
require(read_role(_role_id) != bytes32(0x0));
_group_id = ++system.total_groups;
system.groups.append(_group_id);
system.groups_by_id[_group_id].role_id = _role_id;
system.groups_by_id[_group_id].name = _name;
system.groups_by_id[_group_id].document = _document;
_success = true;
}
/**
@notice Returns the group's information
@param _group_id Id of the group
@return {
"_role_id": "Role id of the group",
"_name: "Name of the group",
"_document: "Document of the group"
}
*/
function read_group(uint256 _group_id)
public
constant
returns (uint256 _role_id, bytes32 _name, bytes32 _document, uint256 _members_count)
{
if (system.groups.valid_item(_group_id)) {
_role_id = system.groups_by_id[_group_id].role_id;
_name = system.groups_by_id[_group_id].name;
_document = system.groups_by_id[_group_id].document;
_members_count = read_total_indexed_addresses(system.groups_collection, bytes32(_group_id));
} else {
_role_id = 0;
_name = "invalid";
_document = "";
_members_count = 0;
}
}
/**
@notice Adds new user with the given information to a group
@param _group_id Id of the group
@param _user Address of the new user
@param _document Information of the new user
@return {"_success": "If adding new user to a group is successful"}
*/
function internal_update_add_user_to_group(uint256 _group_id, address _user, bytes32 _document)
internal
returns (bool _success)
{
if (system.groups_by_id[_group_id].members_by_address[_user].active == false && system.group_ids_by_address[_user] == 0 && system.groups_by_id[_group_id].role_id != 0) {
system.groups_by_id[_group_id].members_by_address[_user].active = true;
system.group_ids_by_address[_user] = _group_id;
system.groups_collection.append(bytes32(_group_id), _user);
system.groups_by_id[_group_id].members_by_address[_user].document = _document;
_success = true;
} else {
_success = false;
}
}
/**
@notice Removes user from its group
@param _user Address of the user
@return {"_success": "If removing of user is successful"}
*/
function internal_destroy_group_user(address _user)
internal
returns (bool _success)
{
uint256 _group_id = system.group_ids_by_address[_user];
if ((_group_id == 1) && (system.groups_collection.total(bytes32(_group_id)) == 1)) {
_success = false;
} else {
system.groups_by_id[_group_id].members_by_address[_user].active = false;
system.group_ids_by_address[_user] = 0;
delete system.groups_by_id[_group_id].members_by_address[_user];
_success = system.groups_collection.remove_item(bytes32(_group_id), _user);
}
}
/**
@notice Returns the role id of a user
@param _user Address of a user
@return {"_role_id": "Role id of the user"}
*/
function read_user_role_id(address _user)
constant
public
returns (uint256 _role_id)
{
uint256 _group_id = system.group_ids_by_address[_user];
_role_id = system.groups_by_id[_group_id].role_id;
}
/**
@notice Returns the user's information
@param _user Address of the user
@return {
"_group_id": "Group id of the user",
"_role_id": "Role id of the user",
"_document": "Information of the user"
}
*/
function read_user(address _user)
public
constant
returns (uint256 _group_id, uint256 _role_id, bytes32 _document)
{
_group_id = system.group_ids_by_address[_user];
_role_id = system.groups_by_id[_group_id].role_id;
_document = system.groups_by_id[_group_id].members_by_address[_user].document;
}
/**
@notice Returns the id of the first group
@return {"_group_id": "Id of the first group"}
*/
function read_first_group()
view
external
returns (uint256 _group_id)
{
_group_id = read_first_from_uints(system.groups);
}
/**
@notice Returns the id of the last group
@return {"_group_id": "Id of the last group"}
*/
function read_last_group()
view
external
returns (uint256 _group_id)
{
_group_id = read_last_from_uints(system.groups);
}
/**
@notice Returns the id of the previous group depending on the given current group
@param _current_group_id Id of the current group
@return {"_group_id": "Id of the previous group"}
*/
function read_previous_group_from_group(uint256 _current_group_id)
view
external
returns (uint256 _group_id)
{
_group_id = read_previous_from_uints(system.groups, _current_group_id);
}
/**
@notice Returns the id of the next group depending on the given current group
@param _current_group_id Id of the current group
@return {"_group_id": "Id of the next group"}
*/
function read_next_group_from_group(uint256 _current_group_id)
view
external
returns (uint256 _group_id)
{
_group_id = read_next_from_uints(system.groups, _current_group_id);
}
/**
@notice Returns the total number of groups
@return {"_total_groups": "Total number of groups"}
*/
function read_total_groups()
view
external
returns (uint256 _total_groups)
{
_total_groups = read_total_uints(system.groups);
}
/**
@notice Returns the first user of a group
@param _group_id Id of the group
@return {"_user": "Address of the user"}
*/
function read_first_user_in_group(bytes32 _group_id)
view
external
returns (address _user)
{
_user = read_first_from_indexed_addresses(system.groups_collection, bytes32(_group_id));
}
/**
@notice Returns the last user of a group
@param _group_id Id of the group
@return {"_user": "Address of the user"}
*/
function read_last_user_in_group(bytes32 _group_id)
view
external
returns (address _user)
{
_user = read_last_from_indexed_addresses(system.groups_collection, bytes32(_group_id));
}
/**
@notice Returns the next user of a group depending on the given current user
@param _group_id Id of the group
@param _current_user Address of the current user
@return {"_user": "Address of the next user"}
*/
function read_next_user_in_group(bytes32 _group_id, address _current_user)
view
external
returns (address _user)
{
_user = read_next_from_indexed_addresses(system.groups_collection, bytes32(_group_id), _current_user);
}
/**
@notice Returns the previous user of a group depending on the given current user
@param _group_id Id of the group
@param _current_user Address of the current user
@return {"_user": "Address of the last user"}
*/
function read_previous_user_in_group(bytes32 _group_id, address _current_user)
view
external
returns (address _user)
{
_user = read_previous_from_indexed_addresses(system.groups_collection, bytes32(_group_id), _current_user);
}
/**
@notice Returns the total number of users of a group
@param _group_id Id of the group
@return {"_total_users": "Total number of users"}
*/
function read_total_users_in_group(bytes32 _group_id)
view
external
returns (uint256 _total_users)
{
_total_users = read_total_indexed_addresses(system.groups_collection, bytes32(_group_id));
}
}
// File: contracts/storage/DaoIdentityStorage.sol
contract DaoIdentityStorage is ResolverClient, DaoConstants, DirectoryStorage {
// struct for KYC details
// doc is the IPFS doc hash for any information regarding this KYC
// id_expiration is the UTC timestamp at which this KYC will expire
// at any time after this, the user's KYC is invalid, and that user
// MUST re-KYC before doing any proposer related operation in DigixDAO
struct KycDetails {
bytes32 doc;
uint256 id_expiration;
}
// a mapping of address to the KYC details
mapping (address => KycDetails) kycInfo;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_IDENTITY, _resolver));
require(initialize_directory());
}
function create_group(uint256 _role_id, bytes32 _name, bytes32 _document)
public
returns (bool _success, uint256 _group_id)
{
require(sender_is(CONTRACT_DAO_IDENTITY));
(_success, _group_id) = internal_create_group(_role_id, _name, _document);
require(_success);
}
function create_role(uint256 _role_id, bytes32 _name)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_IDENTITY));
_success = internal_create_role(_role_id, _name);
require(_success);
}
function update_add_user_to_group(uint256 _group_id, address _user, bytes32 _document)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_IDENTITY));
_success = internal_update_add_user_to_group(_group_id, _user, _document);
require(_success);
}
function update_remove_group_user(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_IDENTITY));
_success = internal_destroy_group_user(_user);
require(_success);
}
function update_kyc(address _user, bytes32 _doc, uint256 _id_expiration)
public
{
require(sender_is(CONTRACT_DAO_IDENTITY));
kycInfo[_user].doc = _doc;
kycInfo[_user].id_expiration = _id_expiration;
}
function read_kyc_info(address _user)
public
view
returns (bytes32 _doc, uint256 _id_expiration)
{
_doc = kycInfo[_user].doc;
_id_expiration = kycInfo[_user].id_expiration;
}
function is_kyc_approved(address _user)
public
view
returns (bool _approved)
{
uint256 _id_expiration;
(,_id_expiration) = read_kyc_info(_user);
_approved = _id_expiration > now;
}
}
// File: contracts/common/IdentityCommon.sol
contract IdentityCommon is DaoWhitelistingCommon {
modifier if_root() {
require(identity_storage().read_user_role_id(msg.sender) == ROLES_ROOT);
_;
}
modifier if_founder() {
require(is_founder());
_;
}
function is_founder()
internal
view
returns (bool _isFounder)
{
_isFounder = identity_storage().read_user_role_id(msg.sender) == ROLES_FOUNDERS;
}
modifier if_prl() {
require(identity_storage().read_user_role_id(msg.sender) == ROLES_PRLS);
_;
}
modifier if_kyc_admin() {
require(identity_storage().read_user_role_id(msg.sender) == ROLES_KYC_ADMINS);
_;
}
function identity_storage()
internal
view
returns (DaoIdentityStorage _contract)
{
_contract = DaoIdentityStorage(get_contract(CONTRACT_STORAGE_DAO_IDENTITY));
}
}
// File: contracts/storage/DaoConfigsStorage.sol
contract DaoConfigsStorage is ResolverClient, DaoConstants {
// mapping of config name to config value
// config names can be found in DaoConstants contract
mapping (bytes32 => uint256) public uintConfigs;
// mapping of config name to config value
// config names can be found in DaoConstants contract
mapping (bytes32 => address) public addressConfigs;
// mapping of config name to config value
// config names can be found in DaoConstants contract
mapping (bytes32 => bytes32) public bytesConfigs;
uint256 ONE_BILLION = 1000000000;
uint256 ONE_MILLION = 1000000;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_CONFIG, _resolver));
uintConfigs[CONFIG_LOCKING_PHASE_DURATION] = 10 days;
uintConfigs[CONFIG_QUARTER_DURATION] = QUARTER_DURATION;
uintConfigs[CONFIG_VOTING_COMMIT_PHASE] = 14 days;
uintConfigs[CONFIG_VOTING_PHASE_TOTAL] = 21 days;
uintConfigs[CONFIG_INTERIM_COMMIT_PHASE] = 7 days;
uintConfigs[CONFIG_INTERIM_PHASE_TOTAL] = 14 days;
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR] = 5; // 5%
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR] = 100; // 5%
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR] = 35; // 35%
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR] = 100; // 35%
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR] = 5; // 5%
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR] = 100; // 5%
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR] = 25; // 25%
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR] = 100; // 25%
uintConfigs[CONFIG_DRAFT_QUOTA_NUMERATOR] = 1; // >50%
uintConfigs[CONFIG_DRAFT_QUOTA_DENOMINATOR] = 2; // >50%
uintConfigs[CONFIG_VOTING_QUOTA_NUMERATOR] = 1; // >50%
uintConfigs[CONFIG_VOTING_QUOTA_DENOMINATOR] = 2; // >50%
uintConfigs[CONFIG_QUARTER_POINT_DRAFT_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_INTERIM_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH] = 20000 * ONE_BILLION;
uintConfigs[CONFIG_BONUS_REPUTATION_NUMERATOR] = 15; // 15% bonus for consistent votes
uintConfigs[CONFIG_BONUS_REPUTATION_DENOMINATOR] = 100; // 15% bonus for consistent votes
uintConfigs[CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE] = 28 days;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL] = 35 days;
uintConfigs[CONFIG_SPECIAL_QUOTA_NUMERATOR] = 1; // >50%
uintConfigs[CONFIG_SPECIAL_QUOTA_DENOMINATOR] = 2; // >50%
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR] = 40; // 40%
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR] = 100; // 40%
uintConfigs[CONFIG_MAXIMUM_REPUTATION_DEDUCTION] = 8334 * ONE_MILLION;
uintConfigs[CONFIG_PUNISHMENT_FOR_NOT_LOCKING] = 1666 * ONE_MILLION;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_NUM] = 1; // 1 extra QP gains 1/1 RP
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_DEN] = 1;
uintConfigs[CONFIG_MINIMAL_QUARTER_POINT] = 2 * ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_SCALING_FACTOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_REPUTATION_POINT_SCALING_FACTOR] = 2000 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_MINIMAL_QUARTER_POINT] = 4 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR] = 2000 * ONE_BILLION;
uintConfigs[CONFIG_PORTION_TO_MODERATORS_NUM] = 42; //4.2% of DGX to moderator voting activity
uintConfigs[CONFIG_PORTION_TO_MODERATORS_DEN] = 1000;
uintConfigs[CONFIG_DRAFT_VOTING_PHASE] = 10 days;
uintConfigs[CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE] = 412500 * ONE_MILLION;
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR] = 7; // 7%
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR] = 100; // 7%
uintConfigs[CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION] = 12500 * ONE_MILLION;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM] = 1;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN] = 1;
uintConfigs[CONFIG_VOTE_CLAIMING_DEADLINE] = 10 days;
uintConfigs[CONFIG_MINIMUM_LOCKED_DGD] = 10 * ONE_BILLION;
uintConfigs[CONFIG_MINIMUM_DGD_FOR_MODERATOR] = 842 * ONE_BILLION;
uintConfigs[CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_PREPROPOSAL_COLLATERAL] = 2 ether;
uintConfigs[CONFIG_MAX_FUNDING_FOR_NON_DIGIX] = 100 ether;
uintConfigs[CONFIG_MAX_MILESTONES_FOR_NON_DIGIX] = 5;
uintConfigs[CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER] = 80;
uintConfigs[CONFIG_PROPOSAL_DEAD_DURATION] = 90 days;
uintConfigs[CONFIG_CARBON_VOTE_REPUTATION_BONUS] = 10 * ONE_BILLION;
}
function updateUintConfigs(uint256[] _uintConfigs)
external
{
require(sender_is(CONTRACT_DAO_SPECIAL_VOTING_CLAIMS));
uintConfigs[CONFIG_LOCKING_PHASE_DURATION] = _uintConfigs[0];
/*
This used to be a config that can be changed. Now, _uintConfigs[1] is just a dummy config that doesnt do anything
uintConfigs[CONFIG_QUARTER_DURATION] = _uintConfigs[1];
*/
uintConfigs[CONFIG_VOTING_COMMIT_PHASE] = _uintConfigs[2];
uintConfigs[CONFIG_VOTING_PHASE_TOTAL] = _uintConfigs[3];
uintConfigs[CONFIG_INTERIM_COMMIT_PHASE] = _uintConfigs[4];
uintConfigs[CONFIG_INTERIM_PHASE_TOTAL] = _uintConfigs[5];
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR] = _uintConfigs[6];
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR] = _uintConfigs[7];
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR] = _uintConfigs[8];
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[9];
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR] = _uintConfigs[10];
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR] = _uintConfigs[11];
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR] = _uintConfigs[12];
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[13];
uintConfigs[CONFIG_DRAFT_QUOTA_NUMERATOR] = _uintConfigs[14];
uintConfigs[CONFIG_DRAFT_QUOTA_DENOMINATOR] = _uintConfigs[15];
uintConfigs[CONFIG_VOTING_QUOTA_NUMERATOR] = _uintConfigs[16];
uintConfigs[CONFIG_VOTING_QUOTA_DENOMINATOR] = _uintConfigs[17];
uintConfigs[CONFIG_QUARTER_POINT_DRAFT_VOTE] = _uintConfigs[18];
uintConfigs[CONFIG_QUARTER_POINT_VOTE] = _uintConfigs[19];
uintConfigs[CONFIG_QUARTER_POINT_INTERIM_VOTE] = _uintConfigs[20];
uintConfigs[CONFIG_MINIMAL_QUARTER_POINT] = _uintConfigs[21];
uintConfigs[CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH] = _uintConfigs[22];
uintConfigs[CONFIG_BONUS_REPUTATION_NUMERATOR] = _uintConfigs[23];
uintConfigs[CONFIG_BONUS_REPUTATION_DENOMINATOR] = _uintConfigs[24];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE] = _uintConfigs[25];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL] = _uintConfigs[26];
uintConfigs[CONFIG_SPECIAL_QUOTA_NUMERATOR] = _uintConfigs[27];
uintConfigs[CONFIG_SPECIAL_QUOTA_DENOMINATOR] = _uintConfigs[28];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR] = _uintConfigs[29];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR] = _uintConfigs[30];
uintConfigs[CONFIG_MAXIMUM_REPUTATION_DEDUCTION] = _uintConfigs[31];
uintConfigs[CONFIG_PUNISHMENT_FOR_NOT_LOCKING] = _uintConfigs[32];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_NUM] = _uintConfigs[33];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_DEN] = _uintConfigs[34];
uintConfigs[CONFIG_QUARTER_POINT_SCALING_FACTOR] = _uintConfigs[35];
uintConfigs[CONFIG_REPUTATION_POINT_SCALING_FACTOR] = _uintConfigs[36];
uintConfigs[CONFIG_MODERATOR_MINIMAL_QUARTER_POINT] = _uintConfigs[37];
uintConfigs[CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR] = _uintConfigs[38];
uintConfigs[CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR] = _uintConfigs[39];
uintConfigs[CONFIG_PORTION_TO_MODERATORS_NUM] = _uintConfigs[40];
uintConfigs[CONFIG_PORTION_TO_MODERATORS_DEN] = _uintConfigs[41];
uintConfigs[CONFIG_DRAFT_VOTING_PHASE] = _uintConfigs[42];
uintConfigs[CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE] = _uintConfigs[43];
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR] = _uintConfigs[44];
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[45];
uintConfigs[CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION] = _uintConfigs[46];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM] = _uintConfigs[47];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN] = _uintConfigs[48];
uintConfigs[CONFIG_VOTE_CLAIMING_DEADLINE] = _uintConfigs[49];
uintConfigs[CONFIG_MINIMUM_LOCKED_DGD] = _uintConfigs[50];
uintConfigs[CONFIG_MINIMUM_DGD_FOR_MODERATOR] = _uintConfigs[51];
uintConfigs[CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR] = _uintConfigs[52];
uintConfigs[CONFIG_PREPROPOSAL_COLLATERAL] = _uintConfigs[53];
uintConfigs[CONFIG_MAX_FUNDING_FOR_NON_DIGIX] = _uintConfigs[54];
uintConfigs[CONFIG_MAX_MILESTONES_FOR_NON_DIGIX] = _uintConfigs[55];
uintConfigs[CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER] = _uintConfigs[56];
uintConfigs[CONFIG_PROPOSAL_DEAD_DURATION] = _uintConfigs[57];
uintConfigs[CONFIG_CARBON_VOTE_REPUTATION_BONUS] = _uintConfigs[58];
}
function readUintConfigs()
public
view
returns (uint256[])
{
uint256[] memory _uintConfigs = new uint256[](59);
_uintConfigs[0] = uintConfigs[CONFIG_LOCKING_PHASE_DURATION];
_uintConfigs[1] = uintConfigs[CONFIG_QUARTER_DURATION];
_uintConfigs[2] = uintConfigs[CONFIG_VOTING_COMMIT_PHASE];
_uintConfigs[3] = uintConfigs[CONFIG_VOTING_PHASE_TOTAL];
_uintConfigs[4] = uintConfigs[CONFIG_INTERIM_COMMIT_PHASE];
_uintConfigs[5] = uintConfigs[CONFIG_INTERIM_PHASE_TOTAL];
_uintConfigs[6] = uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR];
_uintConfigs[7] = uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR];
_uintConfigs[8] = uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR];
_uintConfigs[9] = uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR];
_uintConfigs[10] = uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR];
_uintConfigs[11] = uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR];
_uintConfigs[12] = uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR];
_uintConfigs[13] = uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR];
_uintConfigs[14] = uintConfigs[CONFIG_DRAFT_QUOTA_NUMERATOR];
_uintConfigs[15] = uintConfigs[CONFIG_DRAFT_QUOTA_DENOMINATOR];
_uintConfigs[16] = uintConfigs[CONFIG_VOTING_QUOTA_NUMERATOR];
_uintConfigs[17] = uintConfigs[CONFIG_VOTING_QUOTA_DENOMINATOR];
_uintConfigs[18] = uintConfigs[CONFIG_QUARTER_POINT_DRAFT_VOTE];
_uintConfigs[19] = uintConfigs[CONFIG_QUARTER_POINT_VOTE];
_uintConfigs[20] = uintConfigs[CONFIG_QUARTER_POINT_INTERIM_VOTE];
_uintConfigs[21] = uintConfigs[CONFIG_MINIMAL_QUARTER_POINT];
_uintConfigs[22] = uintConfigs[CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH];
_uintConfigs[23] = uintConfigs[CONFIG_BONUS_REPUTATION_NUMERATOR];
_uintConfigs[24] = uintConfigs[CONFIG_BONUS_REPUTATION_DENOMINATOR];
_uintConfigs[25] = uintConfigs[CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE];
_uintConfigs[26] = uintConfigs[CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL];
_uintConfigs[27] = uintConfigs[CONFIG_SPECIAL_QUOTA_NUMERATOR];
_uintConfigs[28] = uintConfigs[CONFIG_SPECIAL_QUOTA_DENOMINATOR];
_uintConfigs[29] = uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR];
_uintConfigs[30] = uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR];
_uintConfigs[31] = uintConfigs[CONFIG_MAXIMUM_REPUTATION_DEDUCTION];
_uintConfigs[32] = uintConfigs[CONFIG_PUNISHMENT_FOR_NOT_LOCKING];
_uintConfigs[33] = uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_NUM];
_uintConfigs[34] = uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_DEN];
_uintConfigs[35] = uintConfigs[CONFIG_QUARTER_POINT_SCALING_FACTOR];
_uintConfigs[36] = uintConfigs[CONFIG_REPUTATION_POINT_SCALING_FACTOR];
_uintConfigs[37] = uintConfigs[CONFIG_MODERATOR_MINIMAL_QUARTER_POINT];
_uintConfigs[38] = uintConfigs[CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR];
_uintConfigs[39] = uintConfigs[CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR];
_uintConfigs[40] = uintConfigs[CONFIG_PORTION_TO_MODERATORS_NUM];
_uintConfigs[41] = uintConfigs[CONFIG_PORTION_TO_MODERATORS_DEN];
_uintConfigs[42] = uintConfigs[CONFIG_DRAFT_VOTING_PHASE];
_uintConfigs[43] = uintConfigs[CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE];
_uintConfigs[44] = uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR];
_uintConfigs[45] = uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR];
_uintConfigs[46] = uintConfigs[CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION];
_uintConfigs[47] = uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM];
_uintConfigs[48] = uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN];
_uintConfigs[49] = uintConfigs[CONFIG_VOTE_CLAIMING_DEADLINE];
_uintConfigs[50] = uintConfigs[CONFIG_MINIMUM_LOCKED_DGD];
_uintConfigs[51] = uintConfigs[CONFIG_MINIMUM_DGD_FOR_MODERATOR];
_uintConfigs[52] = uintConfigs[CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR];
_uintConfigs[53] = uintConfigs[CONFIG_PREPROPOSAL_COLLATERAL];
_uintConfigs[54] = uintConfigs[CONFIG_MAX_FUNDING_FOR_NON_DIGIX];
_uintConfigs[55] = uintConfigs[CONFIG_MAX_MILESTONES_FOR_NON_DIGIX];
_uintConfigs[56] = uintConfigs[CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER];
_uintConfigs[57] = uintConfigs[CONFIG_PROPOSAL_DEAD_DURATION];
_uintConfigs[58] = uintConfigs[CONFIG_CARBON_VOTE_REPUTATION_BONUS];
return _uintConfigs;
}
}
// File: contracts/storage/DaoProposalCounterStorage.sol
contract DaoProposalCounterStorage is ResolverClient, DaoConstants {
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO_COUNTER, _resolver));
}
// This is to mark the number of proposals that have been funded in a specific quarter
// this is to take care of the cap on the number of funded proposals in a quarter
mapping (uint256 => uint256) public proposalCountByQuarter;
function addNonDigixProposalCountInQuarter(uint256 _quarterNumber)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalCountByQuarter[_quarterNumber] = proposalCountByQuarter[_quarterNumber].add(1);
}
}
// File: contracts/storage/DaoUpgradeStorage.sol
contract DaoUpgradeStorage is ResolverClient, DaoConstants {
// this UTC timestamp marks the start of the first quarter
// of DigixDAO. All time related calculations in DaoCommon
// depend on this value
uint256 public startOfFirstQuarter;
// this boolean marks whether the DAO contracts have been replaced
// by newer versions or not. The process of migration is done by deploying
// a new set of contracts, transferring funds from these contracts to the new ones
// migrating some state variables, and finally setting this boolean to true
// All operations in these contracts that may transfer tokens, claim ether,
// boost one's reputation, etc. SHOULD fail if this is true
bool public isReplacedByNewDao;
// this is the address of the new Dao contract
address public newDaoContract;
// this is the address of the new DaoFundingManager contract
// ether funds will be moved from the current version's contract to this
// new contract
address public newDaoFundingManager;
// this is the address of the new DaoRewardsManager contract
// DGX funds will be moved from the current version of contract to this
// new contract
address public newDaoRewardsManager;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO_UPGRADE, _resolver));
}
function setStartOfFirstQuarter(uint256 _start)
public
{
require(sender_is(CONTRACT_DAO));
startOfFirstQuarter = _start;
}
function setNewContractAddresses(
address _newDaoContract,
address _newDaoFundingManager,
address _newDaoRewardsManager
)
public
{
require(sender_is(CONTRACT_DAO));
newDaoContract = _newDaoContract;
newDaoFundingManager = _newDaoFundingManager;
newDaoRewardsManager = _newDaoRewardsManager;
}
function updateForDaoMigration()
public
{
require(sender_is(CONTRACT_DAO));
isReplacedByNewDao = true;
}
}
// File: contracts/storage/DaoSpecialStorage.sol
contract DaoSpecialStorage is DaoWhitelistingCommon {
using DoublyLinkedList for DoublyLinkedList.Bytes;
using DaoStructs for DaoStructs.SpecialProposal;
using DaoStructs for DaoStructs.Voting;
// List of all the special proposals ever created in DigixDAO
DoublyLinkedList.Bytes proposals;
// mapping of the SpecialProposal struct by its ID
// ID is also the IPFS doc hash of the proposal
mapping (bytes32 => DaoStructs.SpecialProposal) proposalsById;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO_SPECIAL, _resolver));
}
function addSpecialProposal(
bytes32 _proposalId,
address _proposer,
uint256[] _uintConfigs,
address[] _addressConfigs,
bytes32[] _bytesConfigs
)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_PROPOSAL));
require(
(proposalsById[_proposalId].proposalId == EMPTY_BYTES) &&
(_proposalId != EMPTY_BYTES)
);
proposals.append(_proposalId);
proposalsById[_proposalId].proposalId = _proposalId;
proposalsById[_proposalId].proposer = _proposer;
proposalsById[_proposalId].timeCreated = now;
proposalsById[_proposalId].uintConfigs = _uintConfigs;
proposalsById[_proposalId].addressConfigs = _addressConfigs;
proposalsById[_proposalId].bytesConfigs = _bytesConfigs;
}
function readProposal(bytes32 _proposalId)
public
view
returns (
bytes32 _id,
address _proposer,
uint256 _timeCreated,
uint256 _timeVotingStarted
)
{
_id = proposalsById[_proposalId].proposalId;
_proposer = proposalsById[_proposalId].proposer;
_timeCreated = proposalsById[_proposalId].timeCreated;
_timeVotingStarted = proposalsById[_proposalId].voting.startTime;
}
function readProposalProposer(bytes32 _proposalId)
public
view
returns (address _proposer)
{
_proposer = proposalsById[_proposalId].proposer;
}
function readConfigs(bytes32 _proposalId)
public
view
returns (
uint256[] memory _uintConfigs,
address[] memory _addressConfigs,
bytes32[] memory _bytesConfigs
)
{
_uintConfigs = proposalsById[_proposalId].uintConfigs;
_addressConfigs = proposalsById[_proposalId].addressConfigs;
_bytesConfigs = proposalsById[_proposalId].bytesConfigs;
}
function readVotingCount(bytes32 _proposalId, address[] _allUsers)
external
view
returns (uint256 _for, uint256 _against)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].voting.countVotes(_allUsers);
}
function readVotingTime(bytes32 _proposalId)
public
view
returns (uint256 _start)
{
require(senderIsAllowedToRead());
_start = proposalsById[_proposalId].voting.startTime;
}
function commitVote(
bytes32 _proposalId,
bytes32 _hash,
address _voter
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].voting.commits[_voter] = _hash;
}
function readComittedVote(bytes32 _proposalId, address _voter)
public
view
returns (bytes32 _commitHash)
{
require(senderIsAllowedToRead());
_commitHash = proposalsById[_proposalId].voting.commits[_voter];
}
function setVotingTime(bytes32 _proposalId, uint256 _time)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_PROPOSAL));
proposalsById[_proposalId].voting.startTime = _time;
}
function readVotingResult(bytes32 _proposalId)
public
view
returns (bool _result)
{
require(senderIsAllowedToRead());
_result = proposalsById[_proposalId].voting.passed;
}
function setPass(bytes32 _proposalId, bool _result)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_VOTING_CLAIMS));
proposalsById[_proposalId].voting.passed = _result;
}
function setVotingClaim(bytes32 _proposalId, bool _claimed)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_VOTING_CLAIMS));
DaoStructs.SpecialProposal storage _proposal = proposalsById[_proposalId];
_proposal.voting.claimed = _claimed;
}
function isClaimed(bytes32 _proposalId)
public
view
returns (bool _claimed)
{
require(senderIsAllowedToRead());
_claimed = proposalsById[_proposalId].voting.claimed;
}
function readVote(bytes32 _proposalId, address _voter)
public
view
returns (bool _vote, uint256 _weight)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].voting.readVote(_voter);
}
function revealVote(
bytes32 _proposalId,
address _voter,
bool _vote,
uint256 _weight
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].voting.revealVote(_voter, _vote, _weight);
}
}
// File: contracts/storage/DaoPointsStorage.sol
contract DaoPointsStorage is ResolverClient, DaoConstants {
// struct for a non-transferrable token
struct Token {
uint256 totalSupply;
mapping (address => uint256) balance;
}
// the reputation point token
// since reputation is cumulative, we only need to store one value
Token reputationPoint;
// since quarter points are specific to quarters, we need a mapping from
// quarter number to the quarter point token for that quarter
mapping (uint256 => Token) quarterPoint;
// the same is the case with quarter moderator points
// these are specific to quarters
mapping (uint256 => Token) quarterModeratorPoint;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_POINTS, _resolver));
}
/// @notice add quarter points for a _participant for a _quarterNumber
function addQuarterPoint(address _participant, uint256 _point, uint256 _quarterNumber)
public
returns (uint256 _newPoint, uint256 _newTotalPoint)
{
require(sender_is_from([CONTRACT_DAO_VOTING, CONTRACT_DAO_VOTING_CLAIMS, EMPTY_BYTES]));
quarterPoint[_quarterNumber].totalSupply = quarterPoint[_quarterNumber].totalSupply.add(_point);
quarterPoint[_quarterNumber].balance[_participant] = quarterPoint[_quarterNumber].balance[_participant].add(_point);
_newPoint = quarterPoint[_quarterNumber].balance[_participant];
_newTotalPoint = quarterPoint[_quarterNumber].totalSupply;
}
function addModeratorQuarterPoint(address _participant, uint256 _point, uint256 _quarterNumber)
public
returns (uint256 _newPoint, uint256 _newTotalPoint)
{
require(sender_is_from([CONTRACT_DAO_VOTING, CONTRACT_DAO_VOTING_CLAIMS, EMPTY_BYTES]));
quarterModeratorPoint[_quarterNumber].totalSupply = quarterModeratorPoint[_quarterNumber].totalSupply.add(_point);
quarterModeratorPoint[_quarterNumber].balance[_participant] = quarterModeratorPoint[_quarterNumber].balance[_participant].add(_point);
_newPoint = quarterModeratorPoint[_quarterNumber].balance[_participant];
_newTotalPoint = quarterModeratorPoint[_quarterNumber].totalSupply;
}
/// @notice get quarter points for a _participant in a _quarterNumber
function getQuarterPoint(address _participant, uint256 _quarterNumber)
public
view
returns (uint256 _point)
{
_point = quarterPoint[_quarterNumber].balance[_participant];
}
function getQuarterModeratorPoint(address _participant, uint256 _quarterNumber)
public
view
returns (uint256 _point)
{
_point = quarterModeratorPoint[_quarterNumber].balance[_participant];
}
/// @notice get total quarter points for a particular _quarterNumber
function getTotalQuarterPoint(uint256 _quarterNumber)
public
view
returns (uint256 _totalPoint)
{
_totalPoint = quarterPoint[_quarterNumber].totalSupply;
}
function getTotalQuarterModeratorPoint(uint256 _quarterNumber)
public
view
returns (uint256 _totalPoint)
{
_totalPoint = quarterModeratorPoint[_quarterNumber].totalSupply;
}
/// @notice add reputation points for a _participant
function increaseReputation(address _participant, uint256 _point)
public
returns (uint256 _newPoint, uint256 _totalPoint)
{
require(sender_is_from([CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_STAKE_LOCKING]));
reputationPoint.totalSupply = reputationPoint.totalSupply.add(_point);
reputationPoint.balance[_participant] = reputationPoint.balance[_participant].add(_point);
_newPoint = reputationPoint.balance[_participant];
_totalPoint = reputationPoint.totalSupply;
}
/// @notice subtract reputation points for a _participant
function reduceReputation(address _participant, uint256 _point)
public
returns (uint256 _newPoint, uint256 _totalPoint)
{
require(sender_is_from([CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_REWARDS_MANAGER, EMPTY_BYTES]));
uint256 _toDeduct = _point;
if (reputationPoint.balance[_participant] > _point) {
reputationPoint.balance[_participant] = reputationPoint.balance[_participant].sub(_point);
} else {
_toDeduct = reputationPoint.balance[_participant];
reputationPoint.balance[_participant] = 0;
}
reputationPoint.totalSupply = reputationPoint.totalSupply.sub(_toDeduct);
_newPoint = reputationPoint.balance[_participant];
_totalPoint = reputationPoint.totalSupply;
}
/// @notice get reputation points for a _participant
function getReputation(address _participant)
public
view
returns (uint256 _point)
{
_point = reputationPoint.balance[_participant];
}
/// @notice get total reputation points distributed in the dao
function getTotalReputation()
public
view
returns (uint256 _totalPoint)
{
_totalPoint = reputationPoint.totalSupply;
}
}
// File: contracts/storage/DaoRewardsStorage.sol
// this contract will receive DGXs fees from the DGX fees distributors
contract DaoRewardsStorage is ResolverClient, DaoConstants {
using DaoStructs for DaoStructs.DaoQuarterInfo;
// DaoQuarterInfo is a struct that stores the quarter specific information
// regarding totalEffectiveDGDs, DGX distribution day, etc. pls check
// docs in lib/DaoStructs
mapping(uint256 => DaoStructs.DaoQuarterInfo) public allQuartersInfo;
// Mapping that stores the DGX that can be claimed as rewards by
// an address (a participant of DigixDAO)
mapping(address => uint256) public claimableDGXs;
// This stores the total DGX value that has been claimed by participants
// this can be done by calling the DaoRewardsManager.claimRewards method
// Note that this value is the only outgoing DGX from DaoRewardsManager contract
// Note that this value also takes into account the demurrage that has been paid
// by participants for simply holding their DGXs in the DaoRewardsManager contract
uint256 public totalDGXsClaimed;
// The Quarter ID in which the user last participated in
// To participate means they had locked more than CONFIG_MINIMUM_LOCKED_DGD
// DGD tokens. In addition, they should not have withdrawn those tokens in the same
// quarter. Basically, in the main phase of the quarter, if DaoCommon.isParticipant(_user)
// was true, they were participants. And that quarter was their lastParticipatedQuarter
mapping (address => uint256) public lastParticipatedQuarter;
// This mapping is only used to update the lastParticipatedQuarter to the
// previousLastParticipatedQuarter in case users lock and withdraw DGDs
// within the same quarter's locking phase
mapping (address => uint256) public previousLastParticipatedQuarter;
// This number marks the Quarter in which the rewards were last updated for that user
// Since the rewards calculation for a specific quarter is only done once that
// quarter is completed, we need this value to note the last quarter when the rewards were updated
// We then start adding the rewards for all quarters after that quarter, until the current quarter
mapping (address => uint256) public lastQuarterThatRewardsWasUpdated;
// Similar as the lastQuarterThatRewardsWasUpdated, but this is for reputation updates
// Note that reputation can also be deducted for no participation (not locking DGDs)
// This value is used to update the reputation based on all quarters from the lastQuarterThatReputationWasUpdated
// to the current quarter
mapping (address => uint256) public lastQuarterThatReputationWasUpdated;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_REWARDS, _resolver));
}
function updateQuarterInfo(
uint256 _quarterNumber,
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _totalEffectiveDGDPreviousQuarter,
uint256 _moderatorMinimalQuarterPoint,
uint256 _moderatorQuarterPointScalingFactor,
uint256 _moderatorReputationPointScalingFactor,
uint256 _totalEffectiveModeratorDGDLastQuarter,
uint256 _dgxDistributionDay,
uint256 _dgxRewardsPoolLastQuarter,
uint256 _sumRewardsFromBeginning
)
public
{
require(sender_is(CONTRACT_DAO_REWARDS_MANAGER));
allQuartersInfo[_quarterNumber].minimalParticipationPoint = _minimalParticipationPoint;
allQuartersInfo[_quarterNumber].quarterPointScalingFactor = _quarterPointScalingFactor;
allQuartersInfo[_quarterNumber].reputationPointScalingFactor = _reputationPointScalingFactor;
allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter = _totalEffectiveDGDPreviousQuarter;
allQuartersInfo[_quarterNumber].moderatorMinimalParticipationPoint = _moderatorMinimalQuarterPoint;
allQuartersInfo[_quarterNumber].moderatorQuarterPointScalingFactor = _moderatorQuarterPointScalingFactor;
allQuartersInfo[_quarterNumber].moderatorReputationPointScalingFactor = _moderatorReputationPointScalingFactor;
allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter = _totalEffectiveModeratorDGDLastQuarter;
allQuartersInfo[_quarterNumber].dgxDistributionDay = _dgxDistributionDay;
allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter = _dgxRewardsPoolLastQuarter;
allQuartersInfo[_quarterNumber].sumRewardsFromBeginning = _sumRewardsFromBeginning;
}
function updateClaimableDGX(address _user, uint256 _newClaimableDGX)
public
{
require(sender_is(CONTRACT_DAO_REWARDS_MANAGER));
claimableDGXs[_user] = _newClaimableDGX;
}
function updateLastParticipatedQuarter(address _user, uint256 _lastQuarter)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
lastParticipatedQuarter[_user] = _lastQuarter;
}
function updatePreviousLastParticipatedQuarter(address _user, uint256 _lastQuarter)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
previousLastParticipatedQuarter[_user] = _lastQuarter;
}
function updateLastQuarterThatRewardsWasUpdated(address _user, uint256 _lastQuarter)
public
{
require(sender_is_from([CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_STAKE_LOCKING, EMPTY_BYTES]));
lastQuarterThatRewardsWasUpdated[_user] = _lastQuarter;
}
function updateLastQuarterThatReputationWasUpdated(address _user, uint256 _lastQuarter)
public
{
require(sender_is_from([CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_STAKE_LOCKING, EMPTY_BYTES]));
lastQuarterThatReputationWasUpdated[_user] = _lastQuarter;
}
function addToTotalDgxClaimed(uint256 _dgxClaimed)
public
{
require(sender_is(CONTRACT_DAO_REWARDS_MANAGER));
totalDGXsClaimed = totalDGXsClaimed.add(_dgxClaimed);
}
function readQuarterInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _totalEffectiveDGDPreviousQuarter,
uint256 _moderatorMinimalQuarterPoint,
uint256 _moderatorQuarterPointScalingFactor,
uint256 _moderatorReputationPointScalingFactor,
uint256 _totalEffectiveModeratorDGDLastQuarter,
uint256 _dgxDistributionDay,
uint256 _dgxRewardsPoolLastQuarter,
uint256 _sumRewardsFromBeginning
)
{
_minimalParticipationPoint = allQuartersInfo[_quarterNumber].minimalParticipationPoint;
_quarterPointScalingFactor = allQuartersInfo[_quarterNumber].quarterPointScalingFactor;
_reputationPointScalingFactor = allQuartersInfo[_quarterNumber].reputationPointScalingFactor;
_totalEffectiveDGDPreviousQuarter = allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter;
_moderatorMinimalQuarterPoint = allQuartersInfo[_quarterNumber].moderatorMinimalParticipationPoint;
_moderatorQuarterPointScalingFactor = allQuartersInfo[_quarterNumber].moderatorQuarterPointScalingFactor;
_moderatorReputationPointScalingFactor = allQuartersInfo[_quarterNumber].moderatorReputationPointScalingFactor;
_totalEffectiveModeratorDGDLastQuarter = allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter;
_dgxDistributionDay = allQuartersInfo[_quarterNumber].dgxDistributionDay;
_dgxRewardsPoolLastQuarter = allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter;
_sumRewardsFromBeginning = allQuartersInfo[_quarterNumber].sumRewardsFromBeginning;
}
function readQuarterGeneralInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _dgxDistributionDay,
uint256 _dgxRewardsPoolLastQuarter,
uint256 _sumRewardsFromBeginning
)
{
_dgxDistributionDay = allQuartersInfo[_quarterNumber].dgxDistributionDay;
_dgxRewardsPoolLastQuarter = allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter;
_sumRewardsFromBeginning = allQuartersInfo[_quarterNumber].sumRewardsFromBeginning;
}
function readQuarterModeratorInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _moderatorMinimalQuarterPoint,
uint256 _moderatorQuarterPointScalingFactor,
uint256 _moderatorReputationPointScalingFactor,
uint256 _totalEffectiveModeratorDGDLastQuarter
)
{
_moderatorMinimalQuarterPoint = allQuartersInfo[_quarterNumber].moderatorMinimalParticipationPoint;
_moderatorQuarterPointScalingFactor = allQuartersInfo[_quarterNumber].moderatorQuarterPointScalingFactor;
_moderatorReputationPointScalingFactor = allQuartersInfo[_quarterNumber].moderatorReputationPointScalingFactor;
_totalEffectiveModeratorDGDLastQuarter = allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter;
}
function readQuarterParticipantInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _totalEffectiveDGDPreviousQuarter
)
{
_minimalParticipationPoint = allQuartersInfo[_quarterNumber].minimalParticipationPoint;
_quarterPointScalingFactor = allQuartersInfo[_quarterNumber].quarterPointScalingFactor;
_reputationPointScalingFactor = allQuartersInfo[_quarterNumber].reputationPointScalingFactor;
_totalEffectiveDGDPreviousQuarter = allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter;
}
function readDgxDistributionDay(uint256 _quarterNumber)
public
view
returns (uint256 _distributionDay)
{
_distributionDay = allQuartersInfo[_quarterNumber].dgxDistributionDay;
}
function readTotalEffectiveDGDLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _totalEffectiveDGDPreviousQuarter)
{
_totalEffectiveDGDPreviousQuarter = allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter;
}
function readTotalEffectiveModeratorDGDLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _totalEffectiveModeratorDGDLastQuarter)
{
_totalEffectiveModeratorDGDLastQuarter = allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter;
}
function readRewardsPoolOfLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _rewardsPool)
{
_rewardsPool = allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter;
}
}
// File: contracts/storage/IntermediateResultsStorage.sol
contract IntermediateResultsStorage is ResolverClient, DaoConstants {
using DaoStructs for DaoStructs.IntermediateResults;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_INTERMEDIATE_RESULTS, _resolver));
}
// There are scenarios in which we must loop across all participants/moderators
// in a function call. For a big number of operations, the function call may be short of gas
// To tackle this, we use an IntermediateResults struct to store the intermediate results
// The same function is then called multiple times until all operations are completed
// If the operations cannot be done in that iteration, the intermediate results are stored
// else, the final outcome is returned
// Please check the lib/DaoStructs for docs on this struct
mapping (bytes32 => DaoStructs.IntermediateResults) allIntermediateResults;
function getIntermediateResults(bytes32 _key)
public
view
returns (
address _countedUntil,
uint256 _currentForCount,
uint256 _currentAgainstCount,
uint256 _currentSumOfEffectiveBalance
)
{
_countedUntil = allIntermediateResults[_key].countedUntil;
_currentForCount = allIntermediateResults[_key].currentForCount;
_currentAgainstCount = allIntermediateResults[_key].currentAgainstCount;
_currentSumOfEffectiveBalance = allIntermediateResults[_key].currentSumOfEffectiveBalance;
}
function resetIntermediateResults(bytes32 _key)
public
{
require(sender_is_from([CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_SPECIAL_VOTING_CLAIMS]));
allIntermediateResults[_key].countedUntil = address(0x0);
}
function setIntermediateResults(
bytes32 _key,
address _countedUntil,
uint256 _currentForCount,
uint256 _currentAgainstCount,
uint256 _currentSumOfEffectiveBalance
)
public
{
require(sender_is_from([CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_SPECIAL_VOTING_CLAIMS]));
allIntermediateResults[_key].countedUntil = _countedUntil;
allIntermediateResults[_key].currentForCount = _currentForCount;
allIntermediateResults[_key].currentAgainstCount = _currentAgainstCount;
allIntermediateResults[_key].currentSumOfEffectiveBalance = _currentSumOfEffectiveBalance;
}
}
// File: contracts/lib/MathHelper.sol
library MathHelper {
using SafeMath for uint256;
function max(uint256 a, uint256 b) internal pure returns (uint256 _max){
_max = b;
if (a > b) {
_max = a;
}
}
function min(uint256 a, uint256 b) internal pure returns (uint256 _min){
_min = b;
if (a < b) {
_min = a;
}
}
function sumNumbers(uint256[] _numbers) internal pure returns (uint256 _sum) {
for (uint256 i=0;i<_numbers.length;i++) {
_sum = _sum.add(_numbers[i]);
}
}
}
// File: contracts/common/DaoCommonMini.sol
contract DaoCommonMini is IdentityCommon {
using MathHelper for MathHelper;
/**
@notice Check if the DAO contracts have been replaced by a new set of contracts
@return _isNotReplaced true if it is not replaced, false if it has already been replaced
*/
function isDaoNotReplaced()
public
view
returns (bool _isNotReplaced)
{
_isNotReplaced = !daoUpgradeStorage().isReplacedByNewDao();
}
/**
@notice Check if it is currently in the locking phase
@dev No governance activities can happen in the locking phase. The locking phase is from t=0 to t=CONFIG_LOCKING_PHASE_DURATION-1
@return _isLockingPhase true if it is in the locking phase
*/
function isLockingPhase()
public
view
returns (bool _isLockingPhase)
{
_isLockingPhase = currentTimeInQuarter() < getUintConfig(CONFIG_LOCKING_PHASE_DURATION);
}
/**
@notice Check if it is currently in a main phase.
@dev The main phase is where all the governance activities could take plase. If the DAO is replaced, there can never be any more main phase.
@return _isMainPhase true if it is in a main phase
*/
function isMainPhase()
public
view
returns (bool _isMainPhase)
{
_isMainPhase =
isDaoNotReplaced() &&
currentTimeInQuarter() >= getUintConfig(CONFIG_LOCKING_PHASE_DURATION);
}
/**
@notice Check if the calculateGlobalRewardsBeforeNewQuarter function has been done for a certain quarter
@dev However, there is no need to run calculateGlobalRewardsBeforeNewQuarter for the first quarter
*/
modifier ifGlobalRewardsSet(uint256 _quarterNumber) {
if (_quarterNumber > 1) {
require(daoRewardsStorage().readDgxDistributionDay(_quarterNumber) > 0);
}
_;
}
/**
@notice require that it is currently during a phase, which is within _relativePhaseStart and _relativePhaseEnd seconds, after the _startingPoint
*/
function requireInPhase(uint256 _startingPoint, uint256 _relativePhaseStart, uint256 _relativePhaseEnd)
internal
view
{
require(_startingPoint > 0);
require(now < _startingPoint.add(_relativePhaseEnd));
require(now >= _startingPoint.add(_relativePhaseStart));
}
/**
@notice Get the current quarter index
@dev Quarter indexes starts from 1
@return _quarterNumber the current quarter index
*/
function currentQuarterNumber()
public
view
returns(uint256 _quarterNumber)
{
_quarterNumber = getQuarterNumber(now);
}
/**
@notice Get the quarter index of a timestamp
@dev Quarter indexes starts from 1
@return _index the quarter index
*/
function getQuarterNumber(uint256 _time)
internal
view
returns (uint256 _index)
{
require(startOfFirstQuarterIsSet());
_index =
_time.sub(daoUpgradeStorage().startOfFirstQuarter())
.div(getUintConfig(CONFIG_QUARTER_DURATION))
.add(1);
}
/**
@notice Get the relative time in quarter of a timestamp
@dev For example, the timeInQuarter of the first second of any quarter n-th is always 1
*/
function timeInQuarter(uint256 _time)
internal
view
returns (uint256 _timeInQuarter)
{
require(startOfFirstQuarterIsSet()); // must be already set
_timeInQuarter =
_time.sub(daoUpgradeStorage().startOfFirstQuarter())
% getUintConfig(CONFIG_QUARTER_DURATION);
}
/**
@notice Check if the start of first quarter is already set
@return _isSet true if start of first quarter is already set
*/
function startOfFirstQuarterIsSet()
internal
view
returns (bool _isSet)
{
_isSet = daoUpgradeStorage().startOfFirstQuarter() != 0;
}
/**
@notice Get the current relative time in the quarter
@dev For example: the currentTimeInQuarter of the first second of any quarter is 1
@return _currentT the current relative time in the quarter
*/
function currentTimeInQuarter()
public
view
returns (uint256 _currentT)
{
_currentT = timeInQuarter(now);
}
/**
@notice Get the time remaining in the quarter
*/
function getTimeLeftInQuarter(uint256 _time)
internal
view
returns (uint256 _timeLeftInQuarter)
{
_timeLeftInQuarter = getUintConfig(CONFIG_QUARTER_DURATION).sub(timeInQuarter(_time));
}
function daoListingService()
internal
view
returns (DaoListingService _contract)
{
_contract = DaoListingService(get_contract(CONTRACT_SERVICE_DAO_LISTING));
}
function daoConfigsStorage()
internal
view
returns (DaoConfigsStorage _contract)
{
_contract = DaoConfigsStorage(get_contract(CONTRACT_STORAGE_DAO_CONFIG));
}
function daoStakeStorage()
internal
view
returns (DaoStakeStorage _contract)
{
_contract = DaoStakeStorage(get_contract(CONTRACT_STORAGE_DAO_STAKE));
}
function daoStorage()
internal
view
returns (DaoStorage _contract)
{
_contract = DaoStorage(get_contract(CONTRACT_STORAGE_DAO));
}
function daoProposalCounterStorage()
internal
view
returns (DaoProposalCounterStorage _contract)
{
_contract = DaoProposalCounterStorage(get_contract(CONTRACT_STORAGE_DAO_COUNTER));
}
function daoUpgradeStorage()
internal
view
returns (DaoUpgradeStorage _contract)
{
_contract = DaoUpgradeStorage(get_contract(CONTRACT_STORAGE_DAO_UPGRADE));
}
function daoSpecialStorage()
internal
view
returns (DaoSpecialStorage _contract)
{
_contract = DaoSpecialStorage(get_contract(CONTRACT_STORAGE_DAO_SPECIAL));
}
function daoPointsStorage()
internal
view
returns (DaoPointsStorage _contract)
{
_contract = DaoPointsStorage(get_contract(CONTRACT_STORAGE_DAO_POINTS));
}
function daoRewardsStorage()
internal
view
returns (DaoRewardsStorage _contract)
{
_contract = DaoRewardsStorage(get_contract(CONTRACT_STORAGE_DAO_REWARDS));
}
function intermediateResultsStorage()
internal
view
returns (IntermediateResultsStorage _contract)
{
_contract = IntermediateResultsStorage(get_contract(CONTRACT_STORAGE_INTERMEDIATE_RESULTS));
}
function getUintConfig(bytes32 _configKey)
public
view
returns (uint256 _configValue)
{
_configValue = daoConfigsStorage().uintConfigs(_configKey);
}
}
// File: contracts/common/DaoCommon.sol
contract DaoCommon is DaoCommonMini {
using MathHelper for MathHelper;
/**
@notice Check if the transaction is called by the proposer of a proposal
@return _isFromProposer true if the caller is the proposer
*/
function isFromProposer(bytes32 _proposalId)
internal
view
returns (bool _isFromProposer)
{
_isFromProposer = msg.sender == daoStorage().readProposalProposer(_proposalId);
}
/**
@notice Check if the proposal can still be "editted", or in other words, added more versions
@dev Once the proposal is finalized, it can no longer be editted. The proposer will still be able to add docs and change fundings though.
@return _isEditable true if the proposal is editable
*/
function isEditable(bytes32 _proposalId)
internal
view
returns (bool _isEditable)
{
bytes32 _finalVersion;
(,,,,,,,_finalVersion,,) = daoStorage().readProposal(_proposalId);
_isEditable = _finalVersion == EMPTY_BYTES;
}
/**
@notice returns the balance of DaoFundingManager, which is the wei in DigixDAO
*/
function weiInDao()
internal
view
returns (uint256 _wei)
{
_wei = get_contract(CONTRACT_DAO_FUNDING_MANAGER).balance;
}
/**
@notice Check if it is after the draft voting phase of the proposal
*/
modifier ifAfterDraftVotingPhase(bytes32 _proposalId) {
uint256 _start = daoStorage().readProposalDraftVotingTime(_proposalId);
require(_start > 0); // Draft voting must have started. In other words, proposer must have finalized the proposal
require(now >= _start.add(getUintConfig(CONFIG_DRAFT_VOTING_PHASE)));
_;
}
modifier ifCommitPhase(bytes32 _proposalId, uint8 _index) {
requireInPhase(
daoStorage().readProposalVotingTime(_proposalId, _index),
0,
getUintConfig(_index == 0 ? CONFIG_VOTING_COMMIT_PHASE : CONFIG_INTERIM_COMMIT_PHASE)
);
_;
}
modifier ifRevealPhase(bytes32 _proposalId, uint256 _index) {
requireInPhase(
daoStorage().readProposalVotingTime(_proposalId, _index),
getUintConfig(_index == 0 ? CONFIG_VOTING_COMMIT_PHASE : CONFIG_INTERIM_COMMIT_PHASE),
getUintConfig(_index == 0 ? CONFIG_VOTING_PHASE_TOTAL : CONFIG_INTERIM_PHASE_TOTAL)
);
_;
}
modifier ifAfterProposalRevealPhase(bytes32 _proposalId, uint256 _index) {
uint256 _start = daoStorage().readProposalVotingTime(_proposalId, _index);
require(_start > 0);
require(now >= _start.add(getUintConfig(_index == 0 ? CONFIG_VOTING_PHASE_TOTAL : CONFIG_INTERIM_PHASE_TOTAL)));
_;
}
modifier ifDraftVotingPhase(bytes32 _proposalId) {
requireInPhase(
daoStorage().readProposalDraftVotingTime(_proposalId),
0,
getUintConfig(CONFIG_DRAFT_VOTING_PHASE)
);
_;
}
modifier isProposalState(bytes32 _proposalId, bytes32 _STATE) {
bytes32 _currentState;
(,,,_currentState,,,,,,) = daoStorage().readProposal(_proposalId);
require(_currentState == _STATE);
_;
}
modifier ifDraftNotClaimed(bytes32 _proposalId) {
require(daoStorage().isDraftClaimed(_proposalId) == false);
_;
}
modifier ifNotClaimed(bytes32 _proposalId, uint256 _index) {
require(daoStorage().isClaimed(_proposalId, _index) == false);
_;
}
modifier ifNotClaimedSpecial(bytes32 _proposalId) {
require(daoSpecialStorage().isClaimed(_proposalId) == false);
_;
}
modifier hasNotRevealed(bytes32 _proposalId, uint256 _index) {
uint256 _voteWeight;
(, _voteWeight) = daoStorage().readVote(_proposalId, _index, msg.sender);
require(_voteWeight == uint(0));
_;
}
modifier hasNotRevealedSpecial(bytes32 _proposalId) {
uint256 _weight;
(,_weight) = daoSpecialStorage().readVote(_proposalId, msg.sender);
require(_weight == uint256(0));
_;
}
modifier ifAfterRevealPhaseSpecial(bytes32 _proposalId) {
uint256 _start = daoSpecialStorage().readVotingTime(_proposalId);
require(_start > 0);
require(now.sub(_start) >= getUintConfig(CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL));
_;
}
modifier ifCommitPhaseSpecial(bytes32 _proposalId) {
requireInPhase(
daoSpecialStorage().readVotingTime(_proposalId),
0,
getUintConfig(CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE)
);
_;
}
modifier ifRevealPhaseSpecial(bytes32 _proposalId) {
requireInPhase(
daoSpecialStorage().readVotingTime(_proposalId),
getUintConfig(CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE),
getUintConfig(CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL)
);
_;
}
function daoWhitelistingStorage()
internal
view
returns (DaoWhitelistingStorage _contract)
{
_contract = DaoWhitelistingStorage(get_contract(CONTRACT_STORAGE_DAO_WHITELISTING));
}
function getAddressConfig(bytes32 _configKey)
public
view
returns (address _configValue)
{
_configValue = daoConfigsStorage().addressConfigs(_configKey);
}
function getBytesConfig(bytes32 _configKey)
public
view
returns (bytes32 _configValue)
{
_configValue = daoConfigsStorage().bytesConfigs(_configKey);
}
/**
@notice Check if a user is a participant in the current quarter
*/
function isParticipant(address _user)
public
view
returns (bool _is)
{
_is =
(daoRewardsStorage().lastParticipatedQuarter(_user) == currentQuarterNumber())
&& (daoStakeStorage().lockedDGDStake(_user) >= getUintConfig(CONFIG_MINIMUM_LOCKED_DGD));
}
/**
@notice Check if a user is a moderator in the current quarter
*/
function isModerator(address _user)
public
view
returns (bool _is)
{
_is =
(daoRewardsStorage().lastParticipatedQuarter(_user) == currentQuarterNumber())
&& (daoStakeStorage().lockedDGDStake(_user) >= getUintConfig(CONFIG_MINIMUM_DGD_FOR_MODERATOR))
&& (daoPointsStorage().getReputation(_user) >= getUintConfig(CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR));
}
/**
@notice Calculate the start of a specific milestone of a specific proposal.
@dev This is calculated from the voting start of the voting round preceding the milestone
This would throw if the voting start is 0 (the voting round has not started yet)
Note that if the milestoneIndex is exactly the same as the number of milestones,
This will just return the end of the last voting round.
*/
function startOfMilestone(bytes32 _proposalId, uint256 _milestoneIndex)
internal
view
returns (uint256 _milestoneStart)
{
uint256 _startOfPrecedingVotingRound = daoStorage().readProposalVotingTime(_proposalId, _milestoneIndex);
require(_startOfPrecedingVotingRound > 0);
// the preceding voting round must have started
if (_milestoneIndex == 0) { // This is the 1st milestone, which starts after voting round 0
_milestoneStart =
_startOfPrecedingVotingRound
.add(getUintConfig(CONFIG_VOTING_PHASE_TOTAL));
} else { // if its the n-th milestone, it starts after voting round n-th
_milestoneStart =
_startOfPrecedingVotingRound
.add(getUintConfig(CONFIG_INTERIM_PHASE_TOTAL));
}
}
/**
@notice Calculate the actual voting start for a voting round, given the tentative start
@dev The tentative start is the ideal start. For example, when a proposer finish a milestone, it should be now
However, sometimes the tentative start is too close to the end of the quarter, hence, the actual voting start should be pushed to the next quarter
*/
function getTimelineForNextVote(
uint256 _index,
uint256 _tentativeVotingStart
)
internal
view
returns (uint256 _actualVotingStart)
{
uint256 _timeLeftInQuarter = getTimeLeftInQuarter(_tentativeVotingStart);
uint256 _votingDuration = getUintConfig(_index == 0 ? CONFIG_VOTING_PHASE_TOTAL : CONFIG_INTERIM_PHASE_TOTAL);
_actualVotingStart = _tentativeVotingStart;
if (timeInQuarter(_tentativeVotingStart) < getUintConfig(CONFIG_LOCKING_PHASE_DURATION)) { // if the tentative start is during a locking phase
_actualVotingStart = _tentativeVotingStart.add(
getUintConfig(CONFIG_LOCKING_PHASE_DURATION).sub(timeInQuarter(_tentativeVotingStart))
);
} else if (_timeLeftInQuarter < _votingDuration.add(getUintConfig(CONFIG_VOTE_CLAIMING_DEADLINE))) { // if the time left in quarter is not enough to vote and claim voting
_actualVotingStart = _tentativeVotingStart.add(
_timeLeftInQuarter.add(getUintConfig(CONFIG_LOCKING_PHASE_DURATION)).add(1)
);
}
}
/**
@notice Check if we can add another non-Digix proposal in this quarter
@dev There is a max cap to the number of non-Digix proposals CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER
*/
function checkNonDigixProposalLimit(bytes32 _proposalId)
internal
view
{
require(isNonDigixProposalsWithinLimit(_proposalId));
}
function isNonDigixProposalsWithinLimit(bytes32 _proposalId)
internal
view
returns (bool _withinLimit)
{
bool _isDigixProposal;
(,,,,,,,,,_isDigixProposal) = daoStorage().readProposal(_proposalId);
_withinLimit = true;
if (!_isDigixProposal) {
_withinLimit = daoProposalCounterStorage().proposalCountByQuarter(currentQuarterNumber()) < getUintConfig(CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER);
}
}
/**
@notice If its a non-Digix proposal, check if the fundings are within limit
@dev There is a max cap to the fundings and number of milestones for non-Digix proposals
*/
function checkNonDigixFundings(uint256[] _milestonesFundings, uint256 _finalReward)
internal
view
{
if (!is_founder()) {
require(_milestonesFundings.length <= getUintConfig(CONFIG_MAX_MILESTONES_FOR_NON_DIGIX));
require(MathHelper.sumNumbers(_milestonesFundings).add(_finalReward) <= getUintConfig(CONFIG_MAX_FUNDING_FOR_NON_DIGIX));
}
}
/**
@notice Check if msg.sender can do operations as a proposer
@dev Note that this function does not check if he is the proposer of the proposal
*/
function senderCanDoProposerOperations()
internal
view
{
require(isMainPhase());
require(isParticipant(msg.sender));
require(identity_storage().is_kyc_approved(msg.sender));
}
}
// File: contracts/interactive/DaoVoting.sol
/**
@title Contract for all voting operations of DAO
@author Digix Holdings
*/
contract DaoVoting is DaoCommon {
constructor(address _resolver) public {
require(init(CONTRACT_DAO_VOTING, _resolver));
}
/**
@notice Function to vote on draft proposal (only Moderators can vote)
@param _proposalId ID of the proposal
@param _vote Boolean, true if voting for, false if voting against
*/
function voteOnDraft(
bytes32 _proposalId,
bool _vote
)
public
ifDraftVotingPhase(_proposalId)
{
require(isMainPhase());
require(isModerator(msg.sender));
address _moderator = msg.sender;
uint256 _moderatorStake = daoStakeStorage().lockedDGDStake(_moderator);
uint256 _voteWeight;
(,_voteWeight) = daoStorage().readDraftVote(_proposalId, _moderator);
daoStorage().addDraftVote(_proposalId, _moderator, _vote, _moderatorStake);
if (_voteWeight == 0) { // just voted the first time
daoPointsStorage().addModeratorQuarterPoint(_moderator, getUintConfig(CONFIG_QUARTER_POINT_DRAFT_VOTE), currentQuarterNumber());
}
}
/**
@notice Function to commit a vote on special proposal
@param _proposalId ID of the proposal
@param _commitHash Hash of the vote to commit (hash = SHA3(address(pub_address), bool(vote), bytes(random string)))
@return {
"_success": "Boolean, true if vote was committed successfully"
}
*/
function commitVoteOnSpecialProposal(
bytes32 _proposalId,
bytes32 _commitHash
)
public
ifCommitPhaseSpecial(_proposalId)
{
require(isParticipant(msg.sender));
daoSpecialStorage().commitVote(_proposalId, _commitHash, msg.sender);
}
/**
@notice Function to reveal a committed vote on special proposal
@dev The lockedDGDStake that would be counted behind a participant's vote is his lockedDGDStake when this function is called
@param _proposalId ID of the proposal
@param _vote Boolean, true if voted for, false if voted against
@param _salt Random bytes used to commit vote
*/
function revealVoteOnSpecialProposal(
bytes32 _proposalId,
bool _vote,
bytes32 _salt
)
public
ifRevealPhaseSpecial(_proposalId)
hasNotRevealedSpecial(_proposalId)
{
require(isParticipant(msg.sender));
require(keccak256(abi.encodePacked(msg.sender, _vote, _salt)) == daoSpecialStorage().readComittedVote(_proposalId, msg.sender));
daoSpecialStorage().revealVote(_proposalId, msg.sender, _vote, daoStakeStorage().lockedDGDStake(msg.sender));
daoPointsStorage().addQuarterPoint(msg.sender, getUintConfig(CONFIG_QUARTER_POINT_VOTE), currentQuarterNumber());
}
/**
@notice Function to commit a vote on proposal (Voting Round)
@param _proposalId ID of the proposal
@param _index Index of the Voting Round
@param _commitHash Hash of the vote to commit (hash = SHA3(address(pub_address), bool(vote), bytes32(random string)))
*/
function commitVoteOnProposal(
bytes32 _proposalId,
uint8 _index,
bytes32 _commitHash
)
public
ifCommitPhase(_proposalId, _index)
{
require(isParticipant(msg.sender));
daoStorage().commitVote(_proposalId, _commitHash, msg.sender, _index);
}
/**
@notice Function to reveal a committed vote on proposal (Voting Round)
@dev The lockedDGDStake that would be counted behind a participant's vote is his lockedDGDStake when this function is called
@param _proposalId ID of the proposal
@param _index Index of the Voting Round
@param _vote Boolean, true if voted for, false if voted against
@param _salt Random bytes used to commit vote
*/
function revealVoteOnProposal(
bytes32 _proposalId,
uint8 _index,
bool _vote,
bytes32 _salt
)
public
ifRevealPhase(_proposalId, _index)
hasNotRevealed(_proposalId, _index)
{
require(isParticipant(msg.sender));
require(keccak256(abi.encodePacked(msg.sender, _vote, _salt)) == daoStorage().readComittedVote(_proposalId, _index, msg.sender));
daoStorage().revealVote(_proposalId, msg.sender, _vote, daoStakeStorage().lockedDGDStake(msg.sender), _index);
daoPointsStorage().addQuarterPoint(
msg.sender,
getUintConfig(_index == 0 ? CONFIG_QUARTER_POINT_VOTE : CONFIG_QUARTER_POINT_INTERIM_VOTE),
currentQuarterNumber()
);
}
} | @dev Lock the resolver from any further modifications. This can only be called from the owner @return _success if the operation is successful | function lock_resolver_forever()
if_owner
public
returns (bool _success)
{
locked_forever = true;
_success = true;
}
| 6,489,442 | [
1,
2531,
326,
5039,
628,
1281,
9271,
17953,
18,
225,
1220,
848,
1338,
506,
2566,
628,
326,
3410,
327,
389,
4768,
309,
326,
1674,
353,
6873,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
445,
2176,
67,
14122,
67,
1405,
502,
1435,
203,
6647,
309,
67,
8443,
203,
6647,
1071,
203,
6647,
1135,
261,
6430,
389,
4768,
13,
203,
225,
288,
203,
565,
8586,
67,
1405,
502,
273,
638,
31,
203,
565,
389,
4768,
273,
638,
31,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0x59b18d50a3820f1eE220235F6Dc27564C5B23daF/sources/UpointClaim.sol | * set request price for oracle job/ | function setRequestPrice(uint256 _price) public onlyOwner {
requestPrice = _price;
}
| 2,659,389 | [
1,
542,
590,
6205,
364,
20865,
1719,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
12475,
5147,
12,
11890,
5034,
389,
8694,
13,
1071,
1338,
5541,
288,
203,
3639,
590,
5147,
273,
389,
8694,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
import "@openzeppelin/contracts/utils/Pausable.sol";
import "./MaticWETH.sol";
import "./Crowdsale.sol";
import "./CappedCrowdsale.sol";
import "./TimedCrowdsale.sol";
import {AccessControlMixin} from "./AccessControlMixin.sol";
import {ContextMixin} from "./ContextMixin.sol";
import {NativeMetaTransaction} from "./NativeMetaTransaction.sol";
contract BadDaysLockedFunds is Pausable, CappedCrowdsale, TimedCrowdsale, ContextMixin, NativeMetaTransaction {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
string public name = "BadDaysLockedFunds";
//Whitelisted addresses that can engage in pre-sale
mapping(address => bool) internal whitelisted;
//Constant counter for a month = 30 days = 2,592,000 seconds
uint256 public oneMonth;
//Acocunt -> Category -> Month -> Amount
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) public claimedTokensForTheMonth;
//Override control to enable withdrawal after TGE has been defined and the pre-sale has been closed
bool internal canWithdraw;
//Override date for the TGE - needs to be manually set
uint256 public dayOfTGE;
//MNFT token address
//IERC20 internal _maticWeth;
/*
Categories
Index from 0 - 12
0 - Team
1 - Operations
2 - Marketing
3 - Advisors
4 - Growth Fund
5 - Escrow Vault
6 - Play Rewards
7 - Seed Round
8 - Strategic Round
9 - Private Round 1
10 - Private Round 2
11 - Public Round
*/
uint256 public activeCatIndex;
//Holder of category with index
mapping(uint256 => Category) public fundCategory;
//variable to hold the funds for category 0 - 6
mapping(address => mapping(uint256 => uint256)) public lockedFundForCategoryFor;
//Balance for a specific wallet of a specific category (0 - 6)
mapping(address => mapping(uint256 => uint256)) public balanceOfLockedFundForCategoryFor;
//Holder of the address of the holder of the allocated fund per category (0 - 6)
mapping(uint256 => address) public accountForCategory;
//total balance of the main vault from start to end, across all categories
uint256 public vaultBalance;
//Struct that defines the configurations of each Category
struct Category {
string desc;
uint256 index;
uint256 lockPeriod;
uint256 periodAfterTGE;
uint256 percentClaimableAfterTGE;
uint256 percentClaimablePerMonth;
}
event SetPresaleSchedule(address sender, uint256 openingTime, uint256 closingTime, uint256 cap, uint256 rate, uint256 index);
event WithdrawTokens(address sender, address beneficiary, uint256 amount);
event UpdateWhitelist(address sender, address[] accounts, bool mode);
event ConfigCategory(string desc, uint256 index, uint256 lockPeriod, uint256 periodAfterTGE, uint256 percentClaimableAfterTGE, uint256 percentClaimablePerMonth);
event LockAllocation(uint256 index, address account, uint256 amount, address sender);
event SetTGE(address sender, uint256 value);
event CanWithdraw(address sender, bool canWithdraw);
event SendFundsAfterTGE(address account, uint256 category, uint256 claimable);
constructor(
IERC20 token, // the token
address tokenwallet // tokenWallet of the token
)
public
{
_setupContractId(name);
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(PAUSER_ROLE, _msgSender());
_setupRole(CREATOR_ROLE, _msgSender());
//_wallet = wallet;
_tokenWallet = tokenwallet;
_token = token;
//_maticWeth = maticWeth;
//For Production Live
/*
_configCategory("Team", 0, 15552000, 0, 0, 500);
_configCategory("Operations", 1, 7776000, 0, 0, 500);
_configCategory("Marketing", 2, 7776000, 0, 0, 500);
_configCategory("Advisors", 3, 2592000, 0, 0, 1000);
_configCategory("Growth Fund", 4, 15552000, 0, 0, 500);
_configCategory("Escrow Vault", 5, 2592000, 0, 0, 10000);
_configCategory("Play Rewards", 6, 2592000, 0, 0, 500);
_configCategory("Seed Round", 7, 2592000, 2592000, 1000, 1125);
_configCategory("Strategic Round", 8, 0, 2419200, 500, 1187);
_configCategory("Private Round 1", 9, 0, 1814400, 700, 1550);
_configCategory("Private Round 2", 10, 0, 1209600, 1300, 1740);
_configCategory("Public Round", 11, 0, 604800, 2000, 4000);
oneMonth = 2592000;
*/
_configCategory("Team", 0, 1080, 0, 0, 500);
_configCategory("Operations", 1, 540, 0, 0, 500);
_configCategory("Marketing", 2, 540, 0, 0, 500);
_configCategory("Advisors", 3, 180, 0, 0, 1000);
_configCategory("Growth Fund", 4, 1080, 0, 0, 500);
_configCategory("Escrow Vault", 5, 180, 0, 0, 10000);
_configCategory("Play Rewards", 6, 180, 0, 0, 500);
_configCategory("Seed Round", 7, 180, 180, 1000, 1125);
_configCategory("Strategic Round", 8, 0, 168, 500, 1187);
_configCategory("Private Round 1", 9, 0, 126, 700, 1550);
_configCategory("Private Round 2", 10, 0, 84, 1300, 1740);
_configCategory("Public Round", 11, 0, 42, 2000, 4000);
oneMonth = 180;
_initializeEIP712(name);
}
function pause() external only(PAUSER_ROLE) {
_pause();
}
function unpause() external only(PAUSER_ROLE) {
_unpause();
}
function _msgSender() internal override view returns (address payable sender)
{
return ContextMixin.msgSender();
}
//function isApprovedToSpend(address account) external view returns (uint256) {
// return _maticWeth.allowance(account, address(this));
//}
function setTGE(uint256 value) external only(CREATOR_ROLE) {
dayOfTGE = value;
emit SetTGE(_msgSender(), value);
}
/// @notice This fuction configures aech category for the token sale
/// @param desc - name of the category
/// @param index - base 0 index of the category
/// @param lockPeriod - lock period in seconds
/// @param periodAfterTGE - lock period after TGE in seconds
/// @param percentClaimableAfterTGE - percent for initial withdrawal after TGE. Note. Actual percent * 100
/// @param percentClaimablePerMonth - monthly withdrawal percentage. Note. Actual percent * 100
function _configCategory(string memory desc, uint256 index, uint256 lockPeriod, uint256 periodAfterTGE, uint256 percentClaimableAfterTGE, uint256 percentClaimablePerMonth) internal {
fundCategory[index] = Category(
desc,
index,
lockPeriod,
periodAfterTGE,
percentClaimableAfterTGE,
percentClaimablePerMonth
);
}
function configCategory(string memory desc, uint256 index, uint256 lockPeriod, uint256 periodAfterTGE, uint256 percentClaimableAfterTGE, uint256 percentClaimablePerMonth)
external only(CREATOR_ROLE) {
_configCategory(desc, index, lockPeriod, periodAfterTGE, percentClaimableAfterTGE, percentClaimablePerMonth);
emit ConfigCategory(desc, index, lockPeriod, periodAfterTGE, percentClaimableAfterTGE, percentClaimablePerMonth);
}
function getCategoryConfig(uint256 code) external view
returns (string memory desc, uint256 index, uint256 lockPeriod, uint256 periodAfterTGE, uint256 percentClaimableAfterTGE, uint256 percentClaimablePerMonth) {
Category storage category = fundCategory[code];
return(category.desc, category.index, category.lockPeriod, category.periodAfterTGE, category.percentClaimableAfterTGE, category.percentClaimablePerMonth);
}
/**
* @notice This locks a specific fund for a specified wallet. Funds can be withdrawn on a monthly
* basis depending on the configuration.
* @param index - Category index for the locked funds
* @param account - Wallet address to be assigned to the locked funds. Monthly claimable amount will
* be sent to this address.
* @param amount - Amount in token bits to be locked for the specific account and category
*/
function lockAllocation(uint256 index, address account, uint256 amount) external only(CREATOR_ROLE) {
require(index <= 6, "BadDaysCrowdsale: Invalid category");
require(account != address(0), "BadDaysCrowdsale: recipient cannot be address 0");
address holder = accountForCategory[index];
if(holder != address(0)) {
require(holder == account, "Category already assigned to address");
}
lockedFundForCategoryFor[account][index] = lockedFundForCategoryFor[account][index].add(amount);
balanceOfLockedFundForCategoryFor[account][index] = balanceOfLockedFundForCategoryFor[account][index].add(amount);
accountForCategory[index] = account;
vaultBalance = vaultBalance.add(amount);
_token.safeTransferFrom(_tokenWallet, address(this), amount);
emit LockAllocation(index, account, amount, _msgSender());
}
function getClaimableLockedFunds(address account, uint256 index) external view returns(uint256) {
require(dayOfTGE > 0, "BadDaysCrowdsale: No TGE yet");
require(index <= 6, "BadDaysCrowdsale: Invalid category");
require(lockedFundForCategoryFor[account][index] > 0, "BadDaysCrowdsale: No fund for this account");
require(balanceOfLockedFundForCategoryFor[account][index] > 0, "BadDaysCrowdsale: Zero balance for this account");
Category storage category = fundCategory[index];
require(block.timestamp > dayOfTGE.add(category.lockPeriod.mul(1 seconds)), "BadDaysCrowdsale: Funds still locked");
uint256 distMonth = getDistributionMonth();
uint256 lockedMonths = (category.lockPeriod.mul(1 seconds).div(oneMonth)).add(1);
uint256 claimable;
if(block.timestamp > dayOfTGE.add(category.lockPeriod.mul(1 seconds))) {
if(claimedTokensForTheMonth[account][index][distMonth] == 0) {
for (uint256 i = lockedMonths; i <= distMonth; i++) {
if(claimedTokensForTheMonth[account][index][i] == 0) {
claimable = claimable.add((lockedFundForCategoryFor[account][index].mul(category.percentClaimablePerMonth)).div(10000));
if (claimable >= balanceOfLockedFundForCategoryFor[account][index]) break;
}
}
}
if (claimable > 0) {
if (claimable > balanceOfLockedFundForCategoryFor[account][index])
claimable = balanceOfLockedFundForCategoryFor[account][index];
}
}
return claimable;
}
function withdrawLockedFunds(address account, uint256 index) external whenNotPaused only(CREATOR_ROLE) {
require(dayOfTGE > 0, "BadDaysCrowdsale: No TGE yet");
require(index <= 6, "BadDaysCrowdsale: Invalid category");
require(lockedFundForCategoryFor[account][index] > 0, "BadDaysCrowdsale: No fund for this account");
require(balanceOfLockedFundForCategoryFor[account][index] > 0, "BadDaysCrowdsale: Zero balance for this account");
Category storage category = fundCategory[index];
require(block.timestamp > dayOfTGE.add(category.lockPeriod.mul(1 seconds)), "BadDaysCrowdsale: Funds still locked");
uint256 distMonth = getDistributionMonth();
uint256 lockedMonths = (category.lockPeriod.mul(1 seconds).div(oneMonth)).add(1);
uint256 claimable;
if(block.timestamp > dayOfTGE.add(category.lockPeriod.mul(1 seconds))) {
if(claimedTokensForTheMonth[account][index][distMonth] == 0) {
for (uint256 i = lockedMonths; i <= distMonth; i++) {
if(claimedTokensForTheMonth[account][index][i] == 0) {
uint256 monthly = (lockedFundForCategoryFor[account][index].mul(category.percentClaimablePerMonth)).div(10000);
claimable = claimable.add(monthly);
claimedTokensForTheMonth[account][index][i] = monthly;
if (claimable >= balanceOfLockedFundForCategoryFor[account][index]) break;
}
}
}
if (claimable > 0) {
if (claimable > balanceOfLockedFundForCategoryFor[account][index])
claimable = balanceOfLockedFundForCategoryFor[account][index];
balanceOfLockedFundForCategoryFor[account][index] = balanceOfLockedFundForCategoryFor[account][index].sub(claimable);
_token.transfer(account, claimable);
emit WithdrawTokens(_msgSender(), account, claimable);
}
}
}
function switchWithdrawal(bool condition) external only(CREATOR_ROLE) {
require(dayOfTGE > 0,"BadDaysCrowdsale: Missing TGE date");
canWithdraw = condition;
emit CanWithdraw(_msgSender(), canWithdraw);
}
function getDistributionMonth() public view returns(uint256) {
require(dayOfTGE > 0,"BadDaysCrowdsale: Missing TGE date");
return ((block.timestamp.sub(dayOfTGE)).div(oneMonth)).add(1);
}
function updateWhitelist(address[] memory accounts, bool mode) external only(CREATOR_ROLE) {
for (uint256 i = 0; i < accounts.length; i++) {
whitelisted[accounts[i]] = mode;
}
emit UpdateWhitelist(_msgSender(), accounts, mode);
}
function isWhitelisted(address account) public view returns (bool) {
return whitelisted[account];
}
function emergencyWithdraw() external whenPaused only(DEFAULT_ADMIN_ROLE) {
uint256 balance = _token.balanceOf(address(this));
if (balance > 0) {
_token.transfer(getTokenWallet(), balance);
}
}
} | * @notice This locks a specific fund for a specified wallet. Funds can be withdrawn on a monthly basis depending on the configuration. @param index - Category index for the locked funds @param account - Wallet address to be assigned to the locked funds. Monthly claimable amount will be sent to this address. @param amount - Amount in token bits to be locked for the specific account and category/ | function lockAllocation(uint256 index, address account, uint256 amount) external only(CREATOR_ROLE) {
require(index <= 6, "BadDaysCrowdsale: Invalid category");
require(account != address(0), "BadDaysCrowdsale: recipient cannot be address 0");
address holder = accountForCategory[index];
if(holder != address(0)) {
require(holder == account, "Category already assigned to address");
}
lockedFundForCategoryFor[account][index] = lockedFundForCategoryFor[account][index].add(amount);
balanceOfLockedFundForCategoryFor[account][index] = balanceOfLockedFundForCategoryFor[account][index].add(amount);
accountForCategory[index] = account;
vaultBalance = vaultBalance.add(amount);
_token.safeTransferFrom(_tokenWallet, address(this), amount);
emit LockAllocation(index, account, amount, _msgSender());
}
| 13,107,282 | [
1,
2503,
13046,
279,
2923,
284,
1074,
364,
279,
1269,
9230,
18,
478,
19156,
848,
506,
598,
9446,
82,
603,
279,
31114,
10853,
8353,
603,
326,
1664,
18,
225,
770,
300,
9856,
770,
364,
326,
8586,
284,
19156,
225,
2236,
300,
20126,
1758,
358,
506,
6958,
358,
326,
8586,
284,
19156,
18,
10337,
715,
7516,
429,
3844,
903,
506,
3271,
358,
333,
1758,
18,
225,
3844,
300,
16811,
316,
1147,
4125,
358,
506,
8586,
364,
326,
2923,
2236,
471,
3150,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
2176,
17353,
12,
11890,
5034,
770,
16,
1758,
2236,
16,
2254,
5034,
3844,
13,
3903,
1338,
12,
5458,
3575,
67,
16256,
13,
288,
203,
3639,
2583,
12,
1615,
1648,
1666,
16,
315,
6434,
9384,
39,
492,
2377,
5349,
30,
1962,
3150,
8863,
203,
3639,
2583,
12,
4631,
480,
1758,
12,
20,
3631,
315,
6434,
9384,
39,
492,
2377,
5349,
30,
8027,
2780,
506,
1758,
374,
8863,
203,
203,
3639,
1758,
10438,
273,
2236,
1290,
4457,
63,
1615,
15533,
203,
203,
3639,
309,
12,
4505,
480,
1758,
12,
20,
3719,
288,
203,
5411,
2583,
12,
4505,
422,
2236,
16,
315,
4457,
1818,
6958,
358,
1758,
8863,
203,
3639,
289,
203,
540,
203,
3639,
8586,
42,
1074,
1290,
4457,
1290,
63,
4631,
6362,
1615,
65,
273,
8586,
42,
1074,
1290,
4457,
1290,
63,
4631,
6362,
1615,
8009,
1289,
12,
8949,
1769,
203,
3639,
11013,
951,
8966,
42,
1074,
1290,
4457,
1290,
63,
4631,
6362,
1615,
65,
273,
11013,
951,
8966,
42,
1074,
1290,
4457,
1290,
63,
4631,
6362,
1615,
8009,
1289,
12,
8949,
1769,
203,
3639,
2236,
1290,
4457,
63,
1615,
65,
273,
2236,
31,
203,
3639,
9229,
13937,
273,
9229,
13937,
18,
1289,
12,
8949,
1769,
203,
3639,
389,
2316,
18,
4626,
5912,
1265,
24899,
2316,
16936,
16,
1758,
12,
2211,
3631,
3844,
1769,
203,
540,
203,
3639,
3626,
3488,
17353,
12,
1615,
16,
2236,
16,
3844,
16,
389,
3576,
12021,
10663,
203,
565,
289,
203,
377,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
//contract declaration
contract MuskInu {
string public name = "Musk Inu";
string public symbol = "MINU";
uint256 public decimals = 18;
uint256 public totalSupply = 10 ** 12 * 10 ** decimals; // 1,000,000,000,000 total token supply
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
// Events - fire events on state changes etc
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
name;
symbol;
decimals;
totalSupply;
balanceOf[msg.sender] = totalSupply;
}
/// @notice transfer amount of tokens to an address
/// @param _to receiver of token
/// @param _value amount value of token to send
/// @return success as true, for transfer
function transfer(address _to, uint256 _value) external returns (bool success) {
require(balanceOf[msg.sender] >= _value);
_transfer(msg.sender, _to, _value);
return true;
}
/// @dev internal helper transfer function with required safety checks
/// @param _from, where funds coming the sender
/// @param _to receiver of token
/// @param _value amount value of token to send
// Internal function transfer can only be called by this contract
// Emit Transfer Event event
function _transfer(address _from, address _to, uint256 _value) internal {
// Ensure sending is to valid address! 0x0 address cane be used to burn()
require(_to != address(0));
balanceOf[_from] = balanceOf[_from] - (_value);
balanceOf[_to] = balanceOf[_to] + (_value);
emit Transfer(_from, _to, _value);
}
/// @notice Approve other to spend on your behalf eg an exchange
/// @param _spender allowed to spend and a max amount allowed to spend
/// @param _value amount value of token to send
/// @return true, success once address approved
// Emit the Approval event
// Allow _spender to spend up to _value on your behalf
function approve(address _spender, uint256 _value) external returns (bool) {
require(_spender != address(0));
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/// @notice transfer by approved person from original address of an amount within approved limit
/// @param _from, address sending to and the amount to send
/// @param _to receiver of token
/// @param _value amount value of token to send
/// @dev internal helper transfer function with required safety checks
/// @return true, success once transfered from original account
// Allow _spender to spend up to _value on your behalf
function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
require(_value <= balanceOf[_from]);
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] = allowance[_from][msg.sender] - (_value);
_transfer(_from, _to, _value);
return true;
}
} | @notice transfer by approved person from original address of an amount within approved limit @param _from, address sending to and the amount to send @param _to receiver of token @param _value amount value of token to send @dev internal helper transfer function with required safety checks @return true, success once transfered from original account Allow _spender to spend up to _value on your behalf | function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
require(_value <= balanceOf[_from]);
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] = allowance[_from][msg.sender] - (_value);
_transfer(_from, _to, _value);
return true;
}
| 279,118 | [
1,
13866,
635,
20412,
6175,
628,
2282,
1758,
434,
392,
3844,
3470,
20412,
1800,
225,
389,
2080,
16,
1758,
5431,
358,
471,
326,
3844,
358,
1366,
225,
389,
869,
5971,
434,
1147,
225,
389,
1132,
3844,
460,
434,
1147,
358,
1366,
225,
2713,
4222,
7412,
445,
598,
1931,
24179,
4271,
327,
638,
16,
2216,
3647,
7412,
329,
628,
2282,
2236,
7852,
389,
87,
1302,
264,
358,
17571,
731,
358,
389,
1132,
603,
3433,
12433,
6186,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
7412,
1265,
12,
2867,
389,
2080,
16,
1758,
389,
869,
16,
2254,
5034,
389,
1132,
13,
3903,
1135,
261,
6430,
13,
288,
203,
3639,
2583,
24899,
1132,
1648,
11013,
951,
63,
67,
2080,
19226,
203,
3639,
2583,
24899,
1132,
1648,
1699,
1359,
63,
67,
2080,
6362,
3576,
18,
15330,
19226,
203,
3639,
1699,
1359,
63,
67,
2080,
6362,
3576,
18,
15330,
65,
273,
1699,
1359,
63,
67,
2080,
6362,
3576,
18,
15330,
65,
300,
261,
67,
1132,
1769,
203,
3639,
389,
13866,
24899,
2080,
16,
389,
869,
16,
389,
1132,
1769,
203,
3639,
327,
638,
31,
203,
565,
289,
203,
377,
203,
377,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity ^0.4.11;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* Math operations with safety checks
*/
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
/**
* Based on http://www.codecodex.com/wiki/Calculate_an_integer_square_root
*/
function sqrt(uint num) internal returns (uint) {
if (0 == num) { // Avoid zero divide
return 0;
}
uint n = (num / 2) + 1; // Initial estimate, never low
uint n1 = (n + (num / n)) / 2;
while (n1 < n) {
n = n1;
n1 = (n + (num / n)) / 2;
}
return n;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
/**
* @dev Fix for the ERC20 short address attack.
*/
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint representing the amount owned by the passed address.
*/
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
/**
* @title Standard ERC20 token
*
* @dev Implemantation of the basic standart token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
/**
* @dev Aprove the passed address to spend the specified amount of tokens on beahlf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
/**
* @dev Function to check the amount of tokens than an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint specifing the amount of tokens still avaible for the spender.
*/
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
/**
* @title Adshares ICO token
*
* see https://github.com/adshares/ico
*
*/
contract AdsharesToken is StandardToken {
using SafeMath for uint;
// metadata
string public constant name = "Adshares Token";
string public constant symbol = "ADST";
uint public constant decimals = 0;
// crowdsale parameters
uint public constant tokenCreationMin = 10000000;
uint public constant tokenPriceMin = 0.0004 ether;
uint public constant tradeSpreadInvert = 50; // 2%
uint public constant crowdsaleEndLockTime = 1 weeks;
uint public constant fundingUnlockPeriod = 1 weeks;
uint public constant fundingUnlockFractionInvert = 100; // 1 %
// contructor parameters
uint public crowdsaleStartBlock;
address public owner1;
address public owner2;
address public withdrawAddress; // multi-sig wallet that will receive ether
// contract state
bool public minFundingReached;
uint public crowdsaleEndDeclarationTime = 0;
uint public fundingUnlockTime = 0;
uint public unlockedBalance = 0;
uint public withdrawnBalance = 0;
bool public isHalted = false;
// events
event LogBuy(address indexed who, uint tokens, uint purchaseValue, uint supplyAfter);
event LogSell(address indexed who, uint tokens, uint saleValue, uint supplyAfter);
event LogWithdraw(uint amount);
event LogCrowdsaleEnd(bool completed);
/**
* @dev Checks if funding is active
*/
modifier fundingActive() {
// Not yet started
if (block.number < crowdsaleStartBlock) {
throw;
}
// Already ended
if (crowdsaleEndDeclarationTime > 0 && block.timestamp > crowdsaleEndDeclarationTime + crowdsaleEndLockTime) {
throw;
}
_;
}
/**
* @dev Throws if called by any account other than one of the owners.
*/
modifier onlyOwner() {
if (msg.sender != owner1 && msg.sender != owner2) {
throw;
}
_;
}
// constructor
function AdsharesToken (address _owner1, address _owner2, address _withdrawAddress, uint _crowdsaleStartBlock)
{
owner1 = _owner1;
owner2 = _owner2;
withdrawAddress = _withdrawAddress;
crowdsaleStartBlock = _crowdsaleStartBlock;
}
/**
* Returns not yet unlocked balance
*/
function getLockedBalance() private constant returns (uint lockedBalance) {
return this.balance.sub(unlockedBalance);
}
/**
* @dev Calculates how many tokens one can buy for specified value
* @return Amount of tokens one will receive and purchase value without remainder.
*/
function getBuyPrice(uint _bidValue) constant returns (uint tokenCount, uint purchaseValue) {
// Token price formula is twofold. We have flat pricing below tokenCreationMin,
// and above that price linarly increases with supply.
uint flatTokenCount;
uint startSupply;
uint linearBidValue;
if(totalSupply < tokenCreationMin) {
uint maxFlatTokenCount = _bidValue.div(tokenPriceMin);
// entire purchase in flat pricing
if(totalSupply.add(maxFlatTokenCount) <= tokenCreationMin) {
return (maxFlatTokenCount, maxFlatTokenCount.mul(tokenPriceMin));
}
flatTokenCount = tokenCreationMin.sub(totalSupply);
linearBidValue = _bidValue.sub(flatTokenCount.mul(tokenPriceMin));
startSupply = tokenCreationMin;
} else {
flatTokenCount = 0;
linearBidValue = _bidValue;
startSupply = totalSupply;
}
// Solves quadratic equation to calculate maximum token count that can be purchased
uint currentPrice = tokenPriceMin.mul(startSupply).div(tokenCreationMin);
uint delta = (2 * startSupply).mul(2 * startSupply).add(linearBidValue.mul(4 * 1 * 2 * startSupply).div(currentPrice));
uint linearTokenCount = delta.sqrt().sub(2 * startSupply).div(2);
uint linearAvgPrice = currentPrice.add((startSupply+linearTokenCount+1).mul(tokenPriceMin).div(tokenCreationMin)).div(2);
// double check to eliminate rounding errors
linearTokenCount = linearBidValue / linearAvgPrice;
linearAvgPrice = currentPrice.add((startSupply+linearTokenCount+1).mul(tokenPriceMin).div(tokenCreationMin)).div(2);
purchaseValue = linearTokenCount.mul(linearAvgPrice).add(flatTokenCount.mul(tokenPriceMin));
return (
flatTokenCount + linearTokenCount,
purchaseValue
);
}
/**
* @dev Calculates average token price for sale of specified token count
* @return Total value received for given sale size.
*/
function getSellPrice(uint _askSizeTokens) constant returns (uint saleValue) {
uint flatTokenCount;
uint linearTokenMin;
if(totalSupply <= tokenCreationMin) {
return tokenPriceMin * _askSizeTokens;
}
if(totalSupply.sub(_askSizeTokens) < tokenCreationMin) {
flatTokenCount = tokenCreationMin - totalSupply.sub(_askSizeTokens);
linearTokenMin = tokenCreationMin;
} else {
flatTokenCount = 0;
linearTokenMin = totalSupply.sub(_askSizeTokens);
}
uint linearTokenCount = _askSizeTokens - flatTokenCount;
uint minPrice = (linearTokenMin).mul(tokenPriceMin).div(tokenCreationMin);
uint maxPrice = (totalSupply+1).mul(tokenPriceMin).div(tokenCreationMin);
uint linearAveragePrice = minPrice.add(maxPrice).div(2);
return linearAveragePrice.mul(linearTokenCount).add(flatTokenCount.mul(tokenPriceMin));
}
/**
* Default function called by sending Ether to this address with no arguments.
* @dev Buy tokens with market order
*/
function() payable fundingActive
{
buyLimit(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
}
/**
* @dev Buy tokens without price limit
*/
function buy() payable external fundingActive {
buyLimit(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
}
/**
* @dev Buy tokens with limit maximum average price
* @param _maxPrice Maximum price user want to pay for one token
*/
function buyLimit(uint _maxPrice) payable public fundingActive {
require(msg.value >= tokenPriceMin);
assert(!isHalted);
uint boughtTokens;
uint averagePrice;
uint purchaseValue;
(boughtTokens, purchaseValue) = getBuyPrice(msg.value);
if(boughtTokens == 0) {
// bid to small, return ether and abort
msg.sender.transfer(msg.value);
return;
}
averagePrice = purchaseValue.div(boughtTokens);
if(averagePrice > _maxPrice) {
// price too high, return ether and abort
msg.sender.transfer(msg.value);
return;
}
assert(averagePrice >= tokenPriceMin);
assert(purchaseValue <= msg.value);
totalSupply = totalSupply.add(boughtTokens);
balances[msg.sender] = balances[msg.sender].add(boughtTokens);
if(!minFundingReached && totalSupply >= tokenCreationMin) {
minFundingReached = true;
fundingUnlockTime = block.timestamp;
// this.balance contains ether sent in this message
unlockedBalance += this.balance.sub(msg.value).div(tradeSpreadInvert);
}
if(minFundingReached) {
unlockedBalance += purchaseValue.div(tradeSpreadInvert);
}
LogBuy(msg.sender, boughtTokens, purchaseValue, totalSupply);
if(msg.value > purchaseValue) {
msg.sender.transfer(msg.value.sub(purchaseValue));
}
}
/**
* @dev Sell tokens without limit on price
* @param _tokenCount Amount of tokens user wants to sell
*/
function sell(uint _tokenCount) external fundingActive {
sellLimit(_tokenCount, 0);
}
/**
* @dev Sell tokens with limit on minimum average priceprice
* @param _tokenCount Amount of tokens user wants to sell
* @param _minPrice Minimum price user wants to receive for one token
*/
function sellLimit(uint _tokenCount, uint _minPrice) public fundingActive {
require(_tokenCount > 0);
assert(balances[msg.sender] >= _tokenCount);
uint saleValue = getSellPrice(_tokenCount);
uint averagePrice = saleValue.div(_tokenCount);
assert(averagePrice >= tokenPriceMin);
if(minFundingReached) {
averagePrice -= averagePrice.div(tradeSpreadInvert);
saleValue -= saleValue.div(tradeSpreadInvert);
}
if(averagePrice < _minPrice) {
// price too high, abort
return;
}
// not enough ether for buyback
assert(saleValue <= this.balance);
totalSupply = totalSupply.sub(_tokenCount);
balances[msg.sender] = balances[msg.sender].sub(_tokenCount);
LogSell(msg.sender, _tokenCount, saleValue, totalSupply);
msg.sender.transfer(saleValue);
}
/**
* @dev Unlock funds for withdrawal. Only 1% can be unlocked weekly.
*/
function unlockFunds() external onlyOwner fundingActive {
assert(minFundingReached);
assert(block.timestamp >= fundingUnlockTime);
uint unlockedAmount = getLockedBalance().div(fundingUnlockFractionInvert);
unlockedBalance += unlockedAmount;
assert(getLockedBalance() > 0);
fundingUnlockTime += fundingUnlockPeriod;
}
/**
* @dev Withdraw funds. Only unlocked funds can be withdrawn.
*/
function withdrawFunds(uint _value) external onlyOwner fundingActive onlyPayloadSize(32) {
require(_value <= unlockedBalance);
assert(minFundingReached);
unlockedBalance -= _value;
withdrawnBalance += _value;
LogWithdraw(_value);
withdrawAddress.transfer(_value);
}
/**
* @dev Declares that crowdsale is about to end. Users have one week to decide if the want to keep token or sell them to contract.
*/
function declareCrowdsaleEnd() external onlyOwner fundingActive {
assert(minFundingReached);
assert(crowdsaleEndDeclarationTime == 0);
crowdsaleEndDeclarationTime = block.timestamp;
LogCrowdsaleEnd(false);
}
/**
* @dev Can be called one week after initial declaration. Withdraws ether and stops trading. Tokens remain in circulation.
*/
function confirmCrowdsaleEnd() external onlyOwner {
assert(crowdsaleEndDeclarationTime > 0 && block.timestamp > crowdsaleEndDeclarationTime + crowdsaleEndLockTime);
LogCrowdsaleEnd(true);
withdrawAddress.transfer(this.balance);
}
/**
* @dev Halts crowdsale. Can only be called before minimumFunding is reached.
* @dev When contract is halted no one can buy new tokens, but can sell them back to contract.
* @dev Function will be called if minimum funding target isn't reached for extended period of time
*/
function haltCrowdsale() external onlyOwner fundingActive {
assert(!minFundingReached);
isHalted = !isHalted;
}
} | * @dev Checks if funding is active/ Not yet started Already ended | modifier fundingActive() {
if (block.number < crowdsaleStartBlock) {
throw;
}
if (crowdsaleEndDeclarationTime > 0 && block.timestamp > crowdsaleEndDeclarationTime + crowdsaleEndLockTime) {
throw;
}
_;
}
| 12,916,725 | [
1,
4081,
309,
22058,
353,
2695,
19,
2288,
4671,
5746,
17009,
16926,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
9606,
22058,
3896,
1435,
288,
203,
1377,
309,
261,
2629,
18,
2696,
411,
276,
492,
2377,
5349,
1685,
1768,
13,
288,
203,
3639,
604,
31,
203,
1377,
289,
203,
1377,
309,
261,
71,
492,
2377,
5349,
1638,
6094,
950,
405,
374,
597,
1203,
18,
5508,
405,
276,
492,
2377,
5349,
1638,
6094,
950,
397,
276,
492,
2377,
5349,
1638,
2531,
950,
13,
288,
203,
1850,
604,
31,
203,
3639,
289,
203,
1377,
389,
31,
203,
565,
289,
203,
377,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity ^0.4.24;
import "../../open-zeppelin/contracts/token/ERC20/StandardToken.sol";
import "../../mozo/contracts/OwnerERC20.sol";
import "../../common/contracts/ERC20Exchangable.sol";
import "../../common/contracts/Mintable.sol";
import "../../common/contracts/Burnable.sol";
/**
* @title SOLO tokens
* @author Biglabs Pte. Ltd.
*/
contract SOLOToken is StandardToken, OwnerERC20, Mintable, Burnable {
//token name
string public constant name = "SOLO Token";
//token symbol
string public constant symbol = "SOLO";
//token decimals
uint8 public constant decimals = 2;
//contract type
string public constant contractType = "SOLO Token";
//owner of contract
address public owner_;
ERC20Exchangable public treasury;
modifier onlyOwner() {
require(msg.sender == owner_);
_;
}
modifier onlyMinter() {
require(msg.sender == address(treasury));
_;
}
/**
* @dev Constructor
*/
constructor() public {
owner_ = msg.sender;
// constructor
totalSupply_ = 0;
//this is mintable and burnable tokens
//so it will not hold any tokens
}
/**
* @dev Set treasury (minter)
* @param _address Address of treasury (minter)
*/
function setTreasury(address _address) public onlyOwner {
treasury = ERC20Exchangable(_address);
}
/**
* @dev Mint tokens
* @param _value Number of tokens
*/
function mint(uint _value) public onlyMinter {
totalSupply_ = totalSupply_.add(_value);
balances[msg.sender] = balances[msg.sender].add(_value);
emit Mint(msg.sender, _value);
}
/**
* @dev Get smart contract's owner
*/
function owner() public view returns (address) {
return owner_;
}
/**
* @dev Check valid owner
* @param _address Address to check
*/
function isValidOwner(address _address) public view returns(bool) {
if (_address == owner_) {
return true;
}
return false;
}
/**
* @dev batch transferring token
* @notice Sender should check whether he has enough tokens to be transferred
* @param _recipients List of recipients addresses
* @param _values Values to be transferred
*/
function batchTransfer(address[] _recipients, uint[] _values) public {
require(_recipients.length == _values.length);
uint length = _recipients.length;
for (uint i = 0; i < length; i++) {
transfer(_recipients[i], _values[i]);
}
}
/**
* @dev transfer token to Treasury smart contract and exchange to Mozo ERC20 tokens
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function soldSOLO(address _to, uint _value) public returns(bool) {
require(_to != address(0));
_burn(_value);
treasury.autoBuyERC20(msg.sender, _to, _value);
return true;
}
function _burn(uint _value) private {
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burned(msg.sender, _value);
}
}
| * @dev transfer token to Treasury smart contract and exchange to Mozo ERC20 tokens @param _to The address to transfer to. @param _value The amount to be transferred./ | function soldSOLO(address _to, uint _value) public returns(bool) {
require(_to != address(0));
_burn(_value);
treasury.autoBuyERC20(msg.sender, _to, _value);
return true;
}
| 13,114,842 | [
1,
13866,
1147,
358,
399,
266,
345,
22498,
13706,
6835,
471,
7829,
358,
19058,
83,
4232,
39,
3462,
2430,
225,
389,
869,
1021,
1758,
358,
7412,
358,
18,
225,
389,
1132,
1021,
3844,
358,
506,
906,
4193,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
272,
1673,
3584,
1502,
12,
2867,
389,
869,
16,
2254,
389,
1132,
13,
1071,
1135,
12,
6430,
13,
288,
203,
3639,
2583,
24899,
869,
480,
1758,
12,
20,
10019,
203,
3639,
389,
70,
321,
24899,
1132,
1769,
203,
203,
3639,
9787,
345,
22498,
18,
6079,
38,
9835,
654,
39,
3462,
12,
3576,
18,
15330,
16,
389,
869,
16,
389,
1132,
1769,
203,
3639,
327,
638,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0x175798ecA009a416F237Ce5e1Dd86A3F00BeA67B/sources/contracts/NodeDelegator.sol | * @dev Returns to normal state. Contract must be paused/ | function unpause() external {
lrtConfig.onlyAdminRole(msg.sender);
_unpause();
}
| 2,981,999 | [
1,
1356,
358,
2212,
919,
18,
13456,
1297,
506,
17781,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
640,
19476,
1435,
3903,
288,
203,
3639,
328,
3797,
809,
18,
3700,
4446,
2996,
12,
3576,
18,
15330,
1769,
203,
3639,
389,
318,
19476,
5621,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/137/0x6ceb95626A59a2F8B1d0B6DB970F4190B89354C7/sources/contracts/oracle/OracleWeightedPool.sol | All token balances are normalized to behave as if the token had 18 decimals. We assume a token's decimals will not change throughout its lifetime, and store the corresponding scaling factor for each at construction time. These factors are always greater than or equal to one: tokens with more than 18 decimals are not supported. | contract OracleWeightedPool is BaseWeightedPool, InvariantGrowthProtocolFees, PoolPriceOracle {
using FixedPoint for uint256;
using OracleWeightedPoolMiscData for bytes32;
IERC20 internal immutable _token0;
IERC20 internal immutable _token1;
uint256 private immutable _normalizedWeight0;
uint256 private immutable _normalizedWeight1;
uint256 internal immutable _scalingFactor0;
uint256 internal immutable _scalingFactor1;
event OracleEnabledChanged(bool enabled);
struct NewPoolParams {
IVault vault;
string name;
string symbol;
IERC20[] tokens;
uint256 normalizedWeight0;
uint256 normalizedWeight1;
uint256 swapFeePercentage;
uint256 pauseWindowDuration;
uint256 bufferPeriodDuration;
bool oracleEnabled;
address owner;
}
constructor(NewPoolParams memory params)
BaseWeightedPool(
params.vault,
params.name,
params.symbol,
params.tokens,
params.swapFeePercentage,
params.pauseWindowDuration,
params.bufferPeriodDuration,
params.owner,
false
)
{
_require(params.tokens.length == 2, Errors.TOKENS_LENGTH_MUST_BE_2);
_require(params.normalizedWeight0 >= WeightedMath._MIN_WEIGHT, Errors.MIN_WEIGHT);
_require(params.normalizedWeight1 >= WeightedMath._MIN_WEIGHT, Errors.MIN_WEIGHT);
uint256 normalizedSum = params.normalizedWeight0.add(params.normalizedWeight1);
_require(normalizedSum == FixedPoint.ONE, Errors.NORMALIZED_WEIGHT_INVARIANT);
_token0 = params.tokens[0];
_token1 = params.tokens[1];
_scalingFactor0 = _computeScalingFactor(params.tokens[0]);
_scalingFactor1 = _computeScalingFactor(params.tokens[1]);
_normalizedWeight0 = params.normalizedWeight0;
_normalizedWeight1 = params.normalizedWeight1;
_setOracleEnabled(params.oracleEnabled);
}
function getMiscData()
external
view
returns (
int256 logInvariant,
int256 logTotalSupply,
uint256 oracleSampleCreationTimestamp,
uint256 oracleIndex,
bool oracleEnabled,
uint256 swapFeePercentage
)
{
bytes32 miscData = _getMiscData();
logInvariant = miscData.logInvariant();
logTotalSupply = miscData.logTotalSupply();
oracleSampleCreationTimestamp = miscData.oracleSampleCreationTimestamp();
oracleIndex = miscData.oracleIndex();
oracleEnabled = miscData.oracleEnabled();
swapFeePercentage = getSwapFeePercentage();
}
function enableOracle() external whenNotPaused authenticate {
_setOracleEnabled(true);
if (totalSupply() > 0) {
_cacheInvariantAndSupply();
}
}
function enableOracle() external whenNotPaused authenticate {
_setOracleEnabled(true);
if (totalSupply() > 0) {
_cacheInvariantAndSupply();
}
}
function _setOracleEnabled(bool enabled) internal {
_setMiscData(_getMiscData().setOracleEnabled(enabled));
emit OracleEnabledChanged(enabled);
}
function _getNormalizedWeights() internal view virtual override returns (uint256[] memory) {
uint256[] memory normalizedWeights = new uint256[](2);
normalizedWeights[0] = _normalizedWeight0;
normalizedWeights[1] = _normalizedWeight1;
return normalizedWeights;
}
function _onSwapGivenIn(
SwapRequest memory swapRequest,
uint256 currentBalanceTokenIn,
uint256 currentBalanceTokenOut
) internal virtual override returns (uint256) {
bool tokenInIsToken0 = swapRequest.tokenIn == _token0;
_updateOracle(
swapRequest.lastChangeBlock,
tokenInIsToken0 ? currentBalanceTokenIn : currentBalanceTokenOut,
tokenInIsToken0 ? currentBalanceTokenOut : currentBalanceTokenIn
);
return super._onSwapGivenIn(swapRequest, currentBalanceTokenIn, currentBalanceTokenOut);
}
function _onSwapGivenOut(
SwapRequest memory swapRequest,
uint256 currentBalanceTokenIn,
uint256 currentBalanceTokenOut
) internal virtual override returns (uint256) {
bool tokenInIsToken0 = swapRequest.tokenIn == _token0;
_updateOracle(
swapRequest.lastChangeBlock,
tokenInIsToken0 ? currentBalanceTokenIn : currentBalanceTokenOut,
tokenInIsToken0 ? currentBalanceTokenOut : currentBalanceTokenIn
);
return super._onSwapGivenOut(swapRequest, currentBalanceTokenIn, currentBalanceTokenOut);
}
function _onJoinPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
uint256[] memory scalingFactors,
bytes memory userData
) internal virtual override returns (uint256, uint256[] memory) {
_updateOracle(lastChangeBlock, balances[0], balances[1]);
return
super._onJoinPool(
poolId,
sender,
recipient,
balances,
lastChangeBlock,
protocolSwapFeePercentage,
scalingFactors,
userData
);
}
function onJoinPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) public virtual override returns (uint256[] memory, uint256[] memory) {
(uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts) = super.onJoinPool(
poolId,
sender,
recipient,
balances,
lastChangeBlock,
protocolSwapFeePercentage,
userData
);
_cacheInvariantAndSupply();
return (amountsIn, dueProtocolFeeAmounts);
}
function _onExitPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
uint256[] memory scalingFactors,
bytes memory userData
) internal virtual override returns (uint256, uint256[] memory) {
if (_isNotPaused()) {
_updateOracle(lastChangeBlock, balances[0], balances[1]);
}
return
super._onExitPool(
poolId,
sender,
recipient,
balances,
lastChangeBlock,
protocolSwapFeePercentage,
scalingFactors,
userData
);
}
function _onExitPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
uint256[] memory scalingFactors,
bytes memory userData
) internal virtual override returns (uint256, uint256[] memory) {
if (_isNotPaused()) {
_updateOracle(lastChangeBlock, balances[0], balances[1]);
}
return
super._onExitPool(
poolId,
sender,
recipient,
balances,
lastChangeBlock,
protocolSwapFeePercentage,
scalingFactors,
userData
);
}
function onExitPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) public virtual override returns (uint256[] memory, uint256[] memory) {
(uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts) = super.onExitPool(
poolId,
sender,
recipient,
balances,
lastChangeBlock,
protocolSwapFeePercentage,
userData
);
if (_isNotPaused()) {
_cacheInvariantAndSupply();
}
return (amountsOut, dueProtocolFeeAmounts);
}
function onExitPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) public virtual override returns (uint256[] memory, uint256[] memory) {
(uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts) = super.onExitPool(
poolId,
sender,
recipient,
balances,
lastChangeBlock,
protocolSwapFeePercentage,
userData
);
if (_isNotPaused()) {
_cacheInvariantAndSupply();
}
return (amountsOut, dueProtocolFeeAmounts);
}
function _updateOracle(
uint256 lastChangeBlock,
uint256 balanceToken0,
uint256 balanceToken1
) internal {
if (block.number == lastChangeBlock) {
return;
}
bytes32 miscData = _getMiscData();
if (miscData.oracleEnabled()) {
int256 logSpotPrice = OracleWeightedMath._calcLogSpotPrice(
_normalizedWeight0,
balanceToken0,
_normalizedWeight1,
balanceToken1
);
int256 logBPTPrice = OracleWeightedMath._calcLogBPTPrice(
_normalizedWeight0,
balanceToken0,
miscData.logTotalSupply()
);
uint256 oracleCurrentIndex = miscData.oracleIndex();
uint256 oracleUpdatedIndex = _processPriceData(
miscData.oracleSampleCreationTimestamp(),
oracleCurrentIndex,
logSpotPrice,
logBPTPrice,
miscData.logInvariant()
);
if (oracleCurrentIndex != oracleUpdatedIndex) {
_setMiscData(
miscData.setOracleIndex(oracleUpdatedIndex).setOracleSampleCreationTimestamp(block.timestamp)
);
}
}
}
function _updateOracle(
uint256 lastChangeBlock,
uint256 balanceToken0,
uint256 balanceToken1
) internal {
if (block.number == lastChangeBlock) {
return;
}
bytes32 miscData = _getMiscData();
if (miscData.oracleEnabled()) {
int256 logSpotPrice = OracleWeightedMath._calcLogSpotPrice(
_normalizedWeight0,
balanceToken0,
_normalizedWeight1,
balanceToken1
);
int256 logBPTPrice = OracleWeightedMath._calcLogBPTPrice(
_normalizedWeight0,
balanceToken0,
miscData.logTotalSupply()
);
uint256 oracleCurrentIndex = miscData.oracleIndex();
uint256 oracleUpdatedIndex = _processPriceData(
miscData.oracleSampleCreationTimestamp(),
oracleCurrentIndex,
logSpotPrice,
logBPTPrice,
miscData.logInvariant()
);
if (oracleCurrentIndex != oracleUpdatedIndex) {
_setMiscData(
miscData.setOracleIndex(oracleUpdatedIndex).setOracleSampleCreationTimestamp(block.timestamp)
);
}
}
}
function _updateOracle(
uint256 lastChangeBlock,
uint256 balanceToken0,
uint256 balanceToken1
) internal {
if (block.number == lastChangeBlock) {
return;
}
bytes32 miscData = _getMiscData();
if (miscData.oracleEnabled()) {
int256 logSpotPrice = OracleWeightedMath._calcLogSpotPrice(
_normalizedWeight0,
balanceToken0,
_normalizedWeight1,
balanceToken1
);
int256 logBPTPrice = OracleWeightedMath._calcLogBPTPrice(
_normalizedWeight0,
balanceToken0,
miscData.logTotalSupply()
);
uint256 oracleCurrentIndex = miscData.oracleIndex();
uint256 oracleUpdatedIndex = _processPriceData(
miscData.oracleSampleCreationTimestamp(),
oracleCurrentIndex,
logSpotPrice,
logBPTPrice,
miscData.logInvariant()
);
if (oracleCurrentIndex != oracleUpdatedIndex) {
_setMiscData(
miscData.setOracleIndex(oracleUpdatedIndex).setOracleSampleCreationTimestamp(block.timestamp)
);
}
}
}
function _updateOracle(
uint256 lastChangeBlock,
uint256 balanceToken0,
uint256 balanceToken1
) internal {
if (block.number == lastChangeBlock) {
return;
}
bytes32 miscData = _getMiscData();
if (miscData.oracleEnabled()) {
int256 logSpotPrice = OracleWeightedMath._calcLogSpotPrice(
_normalizedWeight0,
balanceToken0,
_normalizedWeight1,
balanceToken1
);
int256 logBPTPrice = OracleWeightedMath._calcLogBPTPrice(
_normalizedWeight0,
balanceToken0,
miscData.logTotalSupply()
);
uint256 oracleCurrentIndex = miscData.oracleIndex();
uint256 oracleUpdatedIndex = _processPriceData(
miscData.oracleSampleCreationTimestamp(),
oracleCurrentIndex,
logSpotPrice,
logBPTPrice,
miscData.logInvariant()
);
if (oracleCurrentIndex != oracleUpdatedIndex) {
_setMiscData(
miscData.setOracleIndex(oracleUpdatedIndex).setOracleSampleCreationTimestamp(block.timestamp)
);
}
}
}
function _cacheInvariantAndSupply() internal {
bytes32 miscData = _getMiscData();
if (miscData.oracleEnabled()) {
_setMiscData(
miscData.setLogInvariant(LogCompression.toLowResLog(getLastInvariant())).setLogTotalSupply(
LogCompression.toLowResLog(totalSupply())
)
);
}
}
function _cacheInvariantAndSupply() internal {
bytes32 miscData = _getMiscData();
if (miscData.oracleEnabled()) {
_setMiscData(
miscData.setLogInvariant(LogCompression.toLowResLog(getLastInvariant())).setLogTotalSupply(
LogCompression.toLowResLog(totalSupply())
)
);
}
}
function _getOracleIndex() internal view override returns (uint256) {
return _getMiscData().oracleIndex();
}
function _scalingFactor(bool token0) internal view returns (uint256) {
return token0 ? _scalingFactor0 : _scalingFactor1;
}
function _scalingFactor(IERC20 token) internal view virtual override returns (uint256) {
return _scalingFactor(token == _token0);
}
function _scalingFactors() internal view virtual override returns (uint256[] memory) {
uint256[] memory scalingFactors = new uint256[](2);
scalingFactors[0] = _scalingFactor0;
scalingFactors[1] = _scalingFactor1;
return scalingFactors;
}
function _getMaxTokens() internal pure virtual override returns (uint256) {
return 2;
}
function _getTotalTokens() internal pure virtual override returns (uint256) {
return 2;
}
function _getNormalizedWeight(IERC20 token) internal view virtual override returns (uint256) {
return token == _token0 ? _normalizedWeight0 : _normalizedWeight1;
}
function _beforeJoinExit(
uint256[] memory preBalances,
uint256[] memory normalizedWeights,
uint256 protocolSwapFeePercentage
) internal virtual override(BaseWeightedPool, InvariantGrowthProtocolFees) {
InvariantGrowthProtocolFees._beforeJoinExit(preBalances, normalizedWeights, protocolSwapFeePercentage);
}
function _afterJoinExit(
bool isJoin,
uint256[] memory preBalances,
uint256[] memory balanceDeltas,
uint256[] memory normalizedWeights
) internal virtual override(BaseWeightedPool, InvariantGrowthProtocolFees) {
InvariantGrowthProtocolFees._afterJoinExit(isJoin, preBalances, balanceDeltas, normalizedWeights);
}
}
| 3,751,478 | [
1,
1595,
1147,
324,
26488,
854,
5640,
358,
31085,
487,
309,
326,
1147,
9323,
6549,
15105,
18,
1660,
6750,
279,
1147,
1807,
15105,
903,
486,
2549,
3059,
659,
2097,
12486,
16,
471,
1707,
326,
4656,
10612,
5578,
364,
1517,
622,
16171,
813,
18,
8646,
14490,
854,
3712,
6802,
2353,
578,
3959,
358,
1245,
30,
2430,
598,
1898,
2353,
6549,
15105,
854,
486,
3260,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
28544,
6544,
329,
2864,
353,
3360,
6544,
329,
2864,
16,
657,
8688,
30948,
451,
5752,
2954,
281,
16,
8828,
5147,
23601,
288,
203,
565,
1450,
15038,
2148,
364,
2254,
5034,
31,
203,
565,
1450,
28544,
6544,
329,
2864,
11729,
71,
751,
364,
1731,
1578,
31,
203,
203,
565,
467,
654,
39,
3462,
2713,
11732,
389,
2316,
20,
31,
203,
565,
467,
654,
39,
3462,
2713,
11732,
389,
2316,
21,
31,
203,
203,
565,
2254,
5034,
3238,
11732,
389,
17762,
6544,
20,
31,
203,
565,
2254,
5034,
3238,
11732,
389,
17762,
6544,
21,
31,
203,
203,
565,
2254,
5034,
2713,
11732,
389,
24576,
6837,
20,
31,
203,
565,
2254,
5034,
2713,
11732,
389,
24576,
6837,
21,
31,
203,
203,
565,
871,
28544,
1526,
5033,
12,
6430,
3696,
1769,
203,
203,
203,
203,
203,
565,
1958,
1166,
2864,
1370,
288,
203,
3639,
467,
12003,
9229,
31,
203,
3639,
533,
508,
31,
203,
3639,
533,
3273,
31,
203,
3639,
467,
654,
39,
3462,
8526,
2430,
31,
203,
3639,
2254,
5034,
5640,
6544,
20,
31,
203,
3639,
2254,
5034,
5640,
6544,
21,
31,
203,
3639,
2254,
5034,
7720,
14667,
16397,
31,
203,
3639,
2254,
5034,
11722,
3829,
5326,
31,
203,
3639,
2254,
5034,
1613,
5027,
5326,
31,
203,
3639,
1426,
20865,
1526,
31,
203,
3639,
1758,
3410,
31,
203,
565,
289,
203,
203,
565,
3885,
12,
1908,
2864,
1370,
3778,
859,
13,
203,
3639,
3360,
6544,
329,
2864,
12,
203,
5411,
859,
18,
26983,
16,
203,
5411,
859,
18,
529,
16,
203,
5411,
859,
18,
7175,
16,
2
]
|
./partial_match/1/0x781f9F05ceCCAC891fCDFFFeA88BD7E9C12715d8/sources/src/interfaces/IMiniMeToken.sol | Events ERC20 Methods Query balance and totalSupply in History Generate and destroy tokens Enable tokens transfers Safety Methods | interface IMiniMeToken {
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(address indexed _owner, address indexed _spender, uint256 _amount);
function transfer(address _to, uint256 _amount) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool success);
function approve(address _spender, uint256 _amount) external returns (bool success);
function allowance(address _owner, address _spender) external returns (uint256 remaining);
function approveAndCall(address _spender, uint256 _amount, bytes calldata _extraData) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
function totalSupply() external view returns (uint);
function balanceOfAt(address _owner, uint _blockNumber) external view returns (uint);
function totalSupplyAt(uint _blockNumber) external view returns (uint);
function generateTokens(address _owner, uint _amount) external returns (bool);
function destroyTokens(address _owner, uint _amount) external returns (bool);
function enableTransfers(bool _transfersEnabled) external;
function claimTokens(address _token) external;
pragma solidity >=0.8.17;
}
| 9,302,487 | [
1,
3783,
4232,
39,
3462,
13063,
2770,
11013,
471,
2078,
3088,
1283,
316,
16058,
6654,
471,
5546,
2430,
9677,
2430,
29375,
348,
1727,
14369,
13063,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
5831,
467,
2930,
77,
4667,
1345,
288,
203,
225,
871,
18381,
329,
5157,
12,
2867,
8808,
389,
2316,
16,
1758,
8808,
389,
5723,
16,
2254,
389,
8949,
1769,
203,
225,
871,
12279,
12,
2867,
8808,
389,
2080,
16,
1758,
8808,
389,
869,
16,
2254,
5034,
389,
8949,
1769,
203,
225,
871,
1166,
10930,
1345,
12,
2867,
8808,
389,
14056,
1345,
16,
2254,
389,
11171,
1768,
1769,
203,
225,
871,
1716,
685,
1125,
12,
2867,
8808,
389,
8443,
16,
1758,
8808,
389,
87,
1302,
264,
16,
2254,
5034,
389,
8949,
1769,
203,
203,
225,
445,
7412,
12,
2867,
389,
869,
16,
2254,
5034,
389,
8949,
13,
3903,
1135,
261,
6430,
2216,
1769,
203,
203,
225,
445,
7412,
1265,
12,
2867,
389,
2080,
16,
1758,
389,
869,
16,
2254,
5034,
389,
8949,
13,
3903,
1135,
261,
6430,
2216,
1769,
203,
203,
225,
445,
6617,
537,
12,
2867,
389,
87,
1302,
264,
16,
2254,
5034,
389,
8949,
13,
3903,
1135,
261,
6430,
2216,
1769,
203,
203,
225,
445,
1699,
1359,
12,
2867,
389,
8443,
16,
1758,
389,
87,
1302,
264,
13,
3903,
1135,
261,
11890,
5034,
4463,
1769,
203,
203,
225,
445,
6617,
537,
1876,
1477,
12,
2867,
389,
87,
1302,
264,
16,
2254,
5034,
389,
8949,
16,
1731,
745,
892,
389,
7763,
751,
13,
3903,
1135,
261,
6430,
2216,
1769,
203,
203,
225,
445,
11013,
951,
12,
2867,
389,
8443,
13,
3903,
1476,
1135,
261,
11890,
5034,
11013,
1769,
203,
203,
225,
445,
2078,
3088,
1283,
1435,
3903,
1476,
1135,
261,
11890,
1769,
203,
203,
225,
2
]
|
./partial_match/42220/0xeD929BB106d6E593f3dF57CE6B2bF60177DF8806/sources/contracts/CarbonCreditBundleToken.sol | @notice Withdraws tokens that have been transferred to the contract @dev This may happen if people accidentally transfer tokens to the bundle instead of using the bundle function @param token_ - The token to withdraw orphans for @return The amount withdrawn to the owner | function withdrawOrphanToken(CarbonCreditToken token_) public returns (uint256) {
uint256 _orphanTokens = token_.balanceOf(address(this)) - bundledAmount[token_];
if (_orphanTokens > 0) {
SafeERC20Upgradeable.safeTransfer(token_, owner(), _orphanTokens);
}
return _orphanTokens;
}
| 3,494,694 | [
1,
1190,
9446,
87,
2430,
716,
1240,
2118,
906,
4193,
358,
326,
6835,
225,
1220,
2026,
5865,
309,
16951,
25961,
1230,
7412,
2430,
358,
326,
3440,
3560,
434,
1450,
326,
3440,
445,
225,
1147,
67,
300,
1021,
1147,
358,
598,
9446,
578,
31574,
364,
327,
1021,
3844,
598,
9446,
82,
358,
326,
3410,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
598,
9446,
30509,
1345,
12,
39,
11801,
16520,
1345,
1147,
67,
13,
1071,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
2254,
5034,
389,
7657,
304,
5157,
273,
1147,
27799,
12296,
951,
12,
2867,
12,
2211,
3719,
300,
324,
24467,
6275,
63,
2316,
67,
15533,
203,
203,
3639,
309,
261,
67,
7657,
304,
5157,
405,
374,
13,
288,
203,
5411,
14060,
654,
39,
3462,
10784,
429,
18,
4626,
5912,
12,
2316,
67,
16,
3410,
9334,
389,
7657,
304,
5157,
1769,
203,
3639,
289,
203,
3639,
327,
389,
7657,
304,
5157,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0x1E90F71365b41C4519B85cAb2d4d0bcA92DEb25F/sources/RainbowRAK.sol | remaining 2% is treated as rewardFees
| uint256 rewardFees = (reward.div(1000)).mul(20); | 15,569,533 | [
1,
17956,
576,
9,
353,
13974,
487,
19890,
2954,
281,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
3639,
2254,
5034,
19890,
2954,
281,
273,
261,
266,
2913,
18,
2892,
12,
18088,
13,
2934,
16411,
12,
3462,
1769,
1850,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0xd0CA3F9B0E22a45536991889B8881642411eB7F8/sources/contracts/LBPController.sol | @notice Creates the CRP smart pool and initializes its parameters @dev Needs owner to have approved the tokens and collateral before calling this (manually and externally) @dev This LBPController becomes the Controller of the CRP and holds its liquidity tokens @dev Most of the logic was taken from https://github.com/balancer-labs/bactions-proxy/blob/master/contracts/BActions.sol Pull the tokens and collateral from Owner and Approve them to CRP Disable swapping. Can be enabled back only when LBP starts Initialize Gradual Weights shift for the whole LBP duration | function createSmartPool() external onlyOwner {
require(address(crp) == address(0), "LBPController.createSmartPool, pool already exists");
CRPFactory factory = CRPFactory(CRPFactoryAddress);
require(poolParams.constituentTokens.length == ConstituentsCount, "ERR_LENGTH_MISMATCH");
require(poolParams.tokenBalances.length == ConstituentsCount, "ERR_LENGTH_MISMATCH");
require(poolParams.tokenWeights.length == ConstituentsCount, "ERR_LENGTH_MISMATCH");
crp = factory.newCrp(BFactoryAddress, poolParams, rights);
IERC20 token = IERC20(poolParams.constituentTokens[TokenIndex]);
require(token.transferFrom(msg.sender, address(this), poolParams.tokenBalances[TokenIndex]), "ERR_TRANSFER_FAILED");
_safeApprove(token, address(crp), poolParams.tokenBalances[TokenIndex]);
IERC20 collateral = IERC20(poolParams.constituentTokens[CollateralIndex]);
require(collateral.transferFrom(msg.sender, address(this), poolParams.tokenBalances[CollateralIndex]), "ERR_TRANSFER_FAILED");
_safeApprove(collateral, address(crp), poolParams.tokenBalances[CollateralIndex]);
crp.createPool(
crpParams.initialSupply,
crpParams.minimumWeightChangeBlockPeriod,
crpParams.addTokenTimeLockInBlocks
);
pool = BPool(crp.bPool());
crp.setPublicSwap(false);
uint[] memory endWeights = new uint[](ConstituentsCount);
endWeights[TokenIndex] = endTokenWeight;
endWeights[CollateralIndex] = endCollateralWeight;
crp.updateWeightsGradually(endWeights, startBlock, endBlock);
}
| 2,969,521 | [
1,
2729,
326,
6732,
52,
13706,
2845,
471,
11643,
2097,
1472,
225,
29164,
3410,
358,
1240,
20412,
326,
2430,
471,
4508,
2045,
287,
1865,
4440,
333,
261,
4728,
3452,
471,
18885,
1230,
13,
225,
1220,
511,
30573,
2933,
12724,
326,
6629,
434,
326,
6732,
52,
471,
14798,
2097,
4501,
372,
24237,
2430,
225,
22099,
434,
326,
4058,
1703,
9830,
628,
2333,
2207,
6662,
18,
832,
19,
18770,
17,
80,
5113,
19,
70,
4905,
17,
5656,
19,
10721,
19,
7525,
19,
16351,
87,
19,
38,
6100,
18,
18281,
14899,
326,
2430,
471,
4508,
2045,
287,
628,
16837,
471,
1716,
685,
537,
2182,
358,
6732,
52,
10639,
7720,
1382,
18,
4480,
506,
3696,
1473,
1338,
1347,
511,
30573,
2542,
9190,
611,
6012,
1462,
15437,
87,
4654,
364,
326,
7339,
511,
30573,
3734,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
445,
752,
23824,
2864,
1435,
3903,
1338,
5541,
288,
203,
565,
2583,
12,
2867,
12,
3353,
84,
13,
422,
1758,
12,
20,
3631,
315,
12995,
52,
2933,
18,
2640,
23824,
2864,
16,
2845,
1818,
1704,
8863,
203,
565,
6732,
52,
1733,
3272,
273,
6732,
52,
1733,
12,
5093,
52,
1733,
1887,
1769,
203,
203,
565,
2583,
12,
6011,
1370,
18,
591,
5223,
10744,
5157,
18,
2469,
422,
735,
5223,
89,
4877,
1380,
16,
315,
9712,
67,
7096,
67,
30062,
11793,
8863,
203,
565,
2583,
12,
6011,
1370,
18,
2316,
38,
26488,
18,
2469,
422,
735,
5223,
89,
4877,
1380,
16,
315,
9712,
67,
7096,
67,
30062,
11793,
8863,
203,
565,
2583,
12,
6011,
1370,
18,
2316,
16595,
18,
2469,
422,
735,
5223,
89,
4877,
1380,
16,
315,
9712,
67,
7096,
67,
30062,
11793,
8863,
203,
203,
565,
4422,
84,
273,
3272,
18,
2704,
12893,
84,
12,
38,
1733,
1887,
16,
2845,
1370,
16,
14989,
1769,
203,
203,
565,
467,
654,
39,
3462,
1147,
273,
467,
654,
39,
3462,
12,
6011,
1370,
18,
591,
5223,
10744,
5157,
63,
1345,
1016,
19226,
203,
565,
2583,
12,
2316,
18,
13866,
1265,
12,
3576,
18,
15330,
16,
1758,
12,
2211,
3631,
2845,
1370,
18,
2316,
38,
26488,
63,
1345,
1016,
65,
3631,
315,
9712,
67,
16596,
6553,
67,
11965,
8863,
203,
565,
389,
4626,
12053,
537,
12,
2316,
16,
1758,
12,
3353,
84,
3631,
2845,
1370,
18,
2316,
38,
26488,
63,
1345,
1016,
19226,
203,
203,
565,
467,
654,
39,
3462,
4508,
2045,
287,
273,
467,
654,
2
]
|
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "./PrizePoolBuilder.sol";
import "../registry/RegistryInterface.sol";
import "../prize-pool/compound/CompoundPrizePoolProxyFactory.sol";
import "../external/compound/CTokenInterface.sol";
/// @title Creates new Compound Prize Pools
/* solium-disable security/no-block-members */
contract CompoundPrizePoolBuilder is PrizePoolBuilder {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
/// @notice The configuration used to initialize the Compound Prize Pool
struct CompoundPrizePoolConfig {
CTokenInterface cToken;
uint256 maxExitFeeMantissa;
uint256 maxTimelockDuration;
}
RegistryInterface public reserveRegistry;
CompoundPrizePoolProxyFactory public compoundPrizePoolProxyFactory;
constructor (
RegistryInterface _reserveRegistry,
CompoundPrizePoolProxyFactory _compoundPrizePoolProxyFactory
) public {
require(address(_reserveRegistry) != address(0), "CompoundPrizePoolBuilder/reserveRegistry-not-zero");
require(address(_compoundPrizePoolProxyFactory) != address(0), "CompoundPrizePoolBuilder/compound-prize-pool-builder-not-zero");
reserveRegistry = _reserveRegistry;
compoundPrizePoolProxyFactory = _compoundPrizePoolProxyFactory;
}
/// @notice Creates a new Compound Prize Pool with a preconfigured prize strategy.
/// @param config The config to use to initialize the Compound Prize Pool
/// @return The Compound Prize Pool
function createCompoundPrizePool(
CompoundPrizePoolConfig calldata config
)
external
returns (CompoundPrizePool)
{
CompoundPrizePool prizePool = compoundPrizePoolProxyFactory.create();
ControlledTokenInterface[] memory tokens;
prizePool.initialize(
reserveRegistry,
tokens,
config.maxExitFeeMantissa,
config.maxTimelockDuration,
config.cToken
);
prizePool.transferOwnership(msg.sender);
emit PrizePoolCreated(msg.sender, address(prizePool));
return prizePool;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "../prize-pool/PrizePool.sol";
import "../prize-strategy/PeriodicPrizeStrategy.sol";
contract PrizePoolBuilder {
using SafeCastUpgradeable for uint256;
event PrizePoolCreated (
address indexed creator,
address indexed prizePool
);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/SafeCastUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/introspection/ERC165CheckerUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
import "@pooltogether/fixed-point/contracts/FixedPoint.sol";
import "../registry/RegistryInterface.sol";
import "../reserve/ReserveInterface.sol";
import "./YieldSource.sol";
import "../token/TokenListenerInterface.sol";
import "../token/TokenListenerLibrary.sol";
import "../token/ControlledToken.sol";
import "../token/TokenControllerInterface.sol";
import "../utils/MappedSinglyLinkedList.sol";
import "./PrizePoolInterface.sol";
/// @title Escrows assets and deposits them into a yield source. Exposes interest to Prize Strategy. Users deposit and withdraw from this contract to participate in Prize Pool.
/// @notice Accounting is managed using Controlled Tokens, whose mint and burn functions can only be called by this contract.
/// @dev Must be inherited to provide specific yield-bearing asset control, such as Compound cTokens
abstract contract PrizePool is PrizePoolInterface, YieldSource, OwnableUpgradeable, ReentrancyGuardUpgradeable, TokenControllerInterface {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
using MappedSinglyLinkedList for MappedSinglyLinkedList.Mapping;
using ERC165CheckerUpgradeable for address;
/// @dev Emitted when an instance is initialized
event Initialized(
address reserveRegistry,
uint256 maxExitFeeMantissa,
uint256 maxTimelockDuration
);
/// @dev Event emitted when controlled token is added
event ControlledTokenAdded(
ControlledTokenInterface indexed token
);
/// @dev Emitted when reserve is captured.
event ReserveFeeCaptured(
uint256 amount
);
event AwardCaptured(
uint256 amount
);
/// @dev Event emitted when assets are deposited
event Deposited(
address indexed operator,
address indexed to,
address indexed token,
uint256 amount,
address referrer
);
/// @dev Event emitted when timelocked funds are re-deposited
event TimelockDeposited(
address indexed operator,
address indexed to,
address indexed token,
uint256 amount
);
/// @dev Event emitted when interest is awarded to a winner
event Awarded(
address indexed winner,
address indexed token,
uint256 amount
);
/// @dev Event emitted when external ERC20s are awarded to a winner
event AwardedExternalERC20(
address indexed winner,
address indexed token,
uint256 amount
);
/// @dev Event emitted when external ERC20s are transferred out
event TransferredExternalERC20(
address indexed to,
address indexed token,
uint256 amount
);
/// @dev Event emitted when external ERC721s are awarded to a winner
event AwardedExternalERC721(
address indexed winner,
address indexed token,
uint256[] tokenIds
);
/// @dev Event emitted when assets are withdrawn instantly
event InstantWithdrawal(
address indexed operator,
address indexed from,
address indexed token,
uint256 amount,
uint256 redeemed,
uint256 exitFee
);
/// @dev Event emitted upon a withdrawal with timelock
event TimelockedWithdrawal(
address indexed operator,
address indexed from,
address indexed token,
uint256 amount,
uint256 unlockTimestamp
);
event ReserveWithdrawal(
address indexed to,
uint256 amount
);
/// @dev Event emitted when timelocked funds are swept back to a user
event TimelockedWithdrawalSwept(
address indexed operator,
address indexed from,
uint256 amount,
uint256 redeemed
);
/// @dev Event emitted when the Liquidity Cap is set
event LiquidityCapSet(
uint256 liquidityCap
);
/// @dev Event emitted when the Credit plan is set
event CreditPlanSet(
address token,
uint128 creditLimitMantissa,
uint128 creditRateMantissa
);
/// @dev Event emitted when the Prize Strategy is set
event PrizeStrategySet(
address indexed prizeStrategy
);
/// @dev Emitted when credit is minted
event CreditMinted(
address indexed user,
address indexed token,
uint256 amount
);
/// @dev Emitted when credit is burned
event CreditBurned(
address indexed user,
address indexed token,
uint256 amount
);
struct CreditPlan {
uint128 creditLimitMantissa;
uint128 creditRateMantissa;
}
struct CreditBalance {
uint192 balance;
uint32 timestamp;
bool initialized;
}
/// @dev Reserve to which reserve fees are sent
RegistryInterface public reserveRegistry;
/// @dev A linked list of all the controlled tokens
MappedSinglyLinkedList.Mapping internal _tokens;
/// @dev The Prize Strategy that this Prize Pool is bound to.
TokenListenerInterface public prizeStrategy;
/// @dev The maximum possible exit fee fraction as a fixed point 18 number.
/// For example, if the maxExitFeeMantissa is "0.1 ether", then the maximum exit fee for a withdrawal of 100 Dai will be 10 Dai
uint256 public maxExitFeeMantissa;
/// @dev The maximum possible timelock duration for a timelocked withdrawal (in seconds).
uint256 public maxTimelockDuration;
/// @dev The total funds that are timelocked.
uint256 public timelockTotalSupply;
/// @dev The total funds that have been allocated to the reserve
uint256 public reserveTotalSupply;
/// @dev The total amount of funds that the prize pool can hold.
uint256 public liquidityCap;
/// @dev the The awardable balance
uint256 internal _currentAwardBalance;
/// @dev The timelocked balances for each user
mapping(address => uint256) internal _timelockBalances;
/// @dev The unlock timestamps for each user
mapping(address => uint256) internal _unlockTimestamps;
/// @dev Stores the credit plan for each token.
mapping(address => CreditPlan) internal _tokenCreditPlans;
/// @dev Stores each users balance of credit per token.
mapping(address => mapping(address => CreditBalance)) internal _tokenCreditBalances;
/// @notice Initializes the Prize Pool
/// @param _controlledTokens Array of ControlledTokens that are controlled by this Prize Pool.
/// @param _maxExitFeeMantissa The maximum exit fee size
/// @param _maxTimelockDuration The maximum length of time the withdraw timelock
function initialize (
RegistryInterface _reserveRegistry,
ControlledTokenInterface[] memory _controlledTokens,
uint256 _maxExitFeeMantissa,
uint256 _maxTimelockDuration
)
public
initializer
{
require(address(_reserveRegistry) != address(0), "PrizePool/reserveRegistry-not-zero");
_tokens.initialize();
for (uint256 i = 0; i < _controlledTokens.length; i++) {
_addControlledToken(_controlledTokens[i]);
}
__Ownable_init();
__ReentrancyGuard_init();
_setLiquidityCap(uint256(-1));
reserveRegistry = _reserveRegistry;
maxExitFeeMantissa = _maxExitFeeMantissa;
maxTimelockDuration = _maxTimelockDuration;
emit Initialized(
address(_reserveRegistry),
maxExitFeeMantissa,
maxTimelockDuration
);
}
/// @dev Returns the address of the underlying ERC20 asset
/// @return The address of the asset
function token() external override view returns (address) {
return address(_token());
}
/// @dev Returns the total underlying balance of all assets. This includes both principal and interest.
/// @return The underlying balance of assets
function balance() external returns (uint256) {
return _balance();
}
/// @dev Checks with the Prize Pool if a specific token type may be awarded as an external prize
/// @param _externalToken The address of the token to check
/// @return True if the token may be awarded, false otherwise
function canAwardExternal(address _externalToken) external view returns (bool) {
return _canAwardExternal(_externalToken);
}
/// @notice Deposits timelocked tokens for a user back into the Prize Pool as another asset.
/// @param to The address receiving the tokens
/// @param amount The amount of timelocked assets to re-deposit
/// @param controlledToken The type of token to be minted in exchange (i.e. tickets or sponsorship)
function timelockDepositTo(
address to,
uint256 amount,
address controlledToken
)
external
onlyControlledToken(controlledToken)
canAddLiquidity(amount)
nonReentrant
{
address operator = _msgSender();
_mint(to, amount, controlledToken, address(0));
_timelockBalances[operator] = _timelockBalances[operator].sub(amount);
timelockTotalSupply = timelockTotalSupply.sub(amount);
emit TimelockDeposited(operator, to, controlledToken, amount);
}
/// @notice Deposit assets into the Prize Pool in exchange for tokens
/// @param to The address receiving the newly minted tokens
/// @param amount The amount of assets to deposit
/// @param controlledToken The address of the type of token the user is minting
/// @param referrer The referrer of the deposit
function depositTo(
address to,
uint256 amount,
address controlledToken,
address referrer
)
external override
onlyControlledToken(controlledToken)
canAddLiquidity(amount)
nonReentrant
{
address operator = _msgSender();
_mint(to, amount, controlledToken, referrer);
_token().safeTransferFrom(operator, address(this), amount);
_supply(amount);
emit Deposited(operator, to, controlledToken, amount, referrer);
}
/// @notice Withdraw assets from the Prize Pool instantly. A fairness fee may be charged for an early exit.
/// @param from The address to redeem tokens from.
/// @param amount The amount of tokens to redeem for assets.
/// @param controlledToken The address of the token to redeem (i.e. ticket or sponsorship)
/// @param maximumExitFee The maximum exit fee the caller is willing to pay. This should be pre-calculated by the calculateExitFee() fxn.
/// @return The actual exit fee paid
function withdrawInstantlyFrom(
address from,
uint256 amount,
address controlledToken,
uint256 maximumExitFee
)
external override
nonReentrant
onlyControlledToken(controlledToken)
returns (uint256)
{
(uint256 exitFee, uint256 burnedCredit) = _calculateEarlyExitFeeLessBurnedCredit(from, controlledToken, amount);
require(exitFee <= maximumExitFee, "PrizePool/exit-fee-exceeds-user-maximum");
// burn the credit
_burnCredit(from, controlledToken, burnedCredit);
// burn the tickets
ControlledToken(controlledToken).controllerBurnFrom(_msgSender(), from, amount);
// redeem the tickets less the fee
uint256 amountLessFee = amount.sub(exitFee);
uint256 redeemed = _redeem(amountLessFee);
_token().safeTransfer(from, redeemed);
emit InstantWithdrawal(_msgSender(), from, controlledToken, amount, redeemed, exitFee);
return exitFee;
}
/// @notice Limits the exit fee to the maximum as hard-coded into the contract
/// @param withdrawalAmount The amount that is attempting to be withdrawn
/// @param exitFee The exit fee to check against the limit
/// @return The passed exit fee if it is less than the maximum, otherwise the maximum fee is returned.
function _limitExitFee(uint256 withdrawalAmount, uint256 exitFee) internal view returns (uint256) {
uint256 maxFee = FixedPoint.multiplyUintByMantissa(withdrawalAmount, maxExitFeeMantissa);
if (exitFee > maxFee) {
exitFee = maxFee;
}
return exitFee;
}
/// @notice Withdraw assets from the Prize Pool by placing them into the timelock.
/// The timelock is used to ensure that the tickets have contributed their fair share of the prize.
/// @dev Note that if the user has previously timelocked funds then this contract will try to sweep them.
/// If the existing timelocked funds are still locked, then the incoming
/// balance is added to their existing balance and the new timelock unlock timestamp will overwrite the old one.
/// @param from The address to withdraw from
/// @param amount The amount to withdraw
/// @param controlledToken The type of token being withdrawn
/// @return The timestamp from which the funds can be swept
function withdrawWithTimelockFrom(
address from,
uint256 amount,
address controlledToken
)
external override
nonReentrant
onlyControlledToken(controlledToken)
returns (uint256)
{
uint256 blockTime = _currentTime();
(uint256 lockDuration, uint256 burnedCredit) = _calculateTimelockDuration(from, controlledToken, amount);
uint256 unlockTimestamp = blockTime.add(lockDuration);
_burnCredit(from, controlledToken, burnedCredit);
ControlledToken(controlledToken).controllerBurnFrom(_msgSender(), from, amount);
_mintTimelock(from, amount, unlockTimestamp);
emit TimelockedWithdrawal(_msgSender(), from, controlledToken, amount, unlockTimestamp);
// return the block at which the funds will be available
return unlockTimestamp;
}
/// @notice Adds to a user's timelock balance. It will attempt to sweep before updating the balance.
/// Note that this will overwrite the previous unlock timestamp.
/// @param user The user whose timelock balance should increase
/// @param amount The amount to increase by
/// @param timestamp The new unlock timestamp
function _mintTimelock(address user, uint256 amount, uint256 timestamp) internal {
// Sweep the old balance, if any
address[] memory users = new address[](1);
users[0] = user;
_sweepTimelockBalances(users);
timelockTotalSupply = timelockTotalSupply.add(amount);
_timelockBalances[user] = _timelockBalances[user].add(amount);
_unlockTimestamps[user] = timestamp;
// if the funds should already be unlocked
if (timestamp <= _currentTime()) {
_sweepTimelockBalances(users);
}
}
/// @notice Updates the Prize Strategy when tokens are transferred between holders.
/// @param from The address the tokens are being transferred from (0 if minting)
/// @param to The address the tokens are being transferred to (0 if burning)
/// @param amount The amount of tokens being trasferred
function beforeTokenTransfer(address from, address to, uint256 amount) external override onlyControlledToken(msg.sender) {
if (from != address(0)) {
uint256 fromBeforeBalance = IERC20Upgradeable(msg.sender).balanceOf(from);
// first accrue credit for their old balance
uint256 newCreditBalance = _calculateCreditBalance(from, msg.sender, fromBeforeBalance, 0);
if (from != to) {
// if they are sending funds to someone else, we need to limit their accrued credit to their new balance
newCreditBalance = _applyCreditLimit(msg.sender, fromBeforeBalance.sub(amount), newCreditBalance);
}
_updateCreditBalance(from, msg.sender, newCreditBalance);
}
if (to != address(0) && to != from) {
_accrueCredit(to, msg.sender, IERC20Upgradeable(msg.sender).balanceOf(to), 0);
}
// if we aren't minting
if (from != address(0) && address(prizeStrategy) != address(0)) {
prizeStrategy.beforeTokenTransfer(from, to, amount, msg.sender);
}
}
/// @notice Returns the balance that is available to award.
/// @dev captureAwardBalance() should be called first
/// @return The total amount of assets to be awarded for the current prize
function awardBalance() external override view returns (uint256) {
return _currentAwardBalance;
}
/// @notice Captures any available interest as award balance.
/// @dev This function also captures the reserve fees.
/// @return The total amount of assets to be awarded for the current prize
function captureAwardBalance() external override nonReentrant returns (uint256) {
uint256 tokenTotalSupply = _tokenTotalSupply();
// it's possible for the balance to be slightly less due to rounding errors in the underlying yield source
uint256 currentBalance = _balance();
uint256 totalInterest = (currentBalance > tokenTotalSupply) ? currentBalance.sub(tokenTotalSupply) : 0;
uint256 unaccountedPrizeBalance = (totalInterest > _currentAwardBalance) ? totalInterest.sub(_currentAwardBalance) : 0;
if (unaccountedPrizeBalance > 0) {
uint256 reserveFee = calculateReserveFee(unaccountedPrizeBalance);
if (reserveFee > 0) {
reserveTotalSupply = reserveTotalSupply.add(reserveFee);
unaccountedPrizeBalance = unaccountedPrizeBalance.sub(reserveFee);
emit ReserveFeeCaptured(reserveFee);
}
_currentAwardBalance = _currentAwardBalance.add(unaccountedPrizeBalance);
emit AwardCaptured(unaccountedPrizeBalance);
}
return _currentAwardBalance;
}
function withdrawReserve(address to) external override onlyReserve returns (uint256) {
uint256 amount = reserveTotalSupply;
reserveTotalSupply = 0;
uint256 redeemed = _redeem(amount);
_token().safeTransfer(address(to), redeemed);
emit ReserveWithdrawal(to, amount);
return redeemed;
}
/// @notice Called by the prize strategy to award prizes.
/// @dev The amount awarded must be less than the awardBalance()
/// @param to The address of the winner that receives the award
/// @param amount The amount of assets to be awarded
/// @param controlledToken The address of the asset token being awarded
function award(
address to,
uint256 amount,
address controlledToken
)
external override
onlyPrizeStrategy
onlyControlledToken(controlledToken)
{
if (amount == 0) {
return;
}
require(amount <= _currentAwardBalance, "PrizePool/award-exceeds-avail");
_currentAwardBalance = _currentAwardBalance.sub(amount);
_mint(to, amount, controlledToken, address(0));
uint256 extraCredit = _calculateEarlyExitFeeNoCredit(controlledToken, amount);
_accrueCredit(to, controlledToken, IERC20Upgradeable(controlledToken).balanceOf(to), extraCredit);
emit Awarded(to, controlledToken, amount);
}
/// @notice Called by the Prize-Strategy to transfer out external ERC20 tokens
/// @dev Used to transfer out tokens held by the Prize Pool. Could be liquidated, or anything.
/// @param to The address of the winner that receives the award
/// @param amount The amount of external assets to be awarded
/// @param externalToken The address of the external asset token being awarded
function transferExternalERC20(
address to,
address externalToken,
uint256 amount
)
external override
onlyPrizeStrategy
{
if (_transferOut(to, externalToken, amount)) {
emit TransferredExternalERC20(to, externalToken, amount);
}
}
/// @notice Called by the Prize-Strategy to award external ERC20 prizes
/// @dev Used to award any arbitrary tokens held by the Prize Pool
/// @param to The address of the winner that receives the award
/// @param amount The amount of external assets to be awarded
/// @param externalToken The address of the external asset token being awarded
function awardExternalERC20(
address to,
address externalToken,
uint256 amount
)
external override
onlyPrizeStrategy
{
if (_transferOut(to, externalToken, amount)) {
emit AwardedExternalERC20(to, externalToken, amount);
}
}
function _transferOut(
address to,
address externalToken,
uint256 amount
)
internal
returns (bool)
{
require(_canAwardExternal(externalToken), "PrizePool/invalid-external-token");
if (amount == 0) {
return false;
}
IERC20Upgradeable(externalToken).safeTransfer(to, amount);
return true;
}
/// @notice Called to mint controlled tokens. Ensures that token listener callbacks are fired.
/// @param to The user who is receiving the tokens
/// @param amount The amount of tokens they are receiving
/// @param controlledToken The token that is going to be minted
/// @param referrer The user who referred the minting
function _mint(address to, uint256 amount, address controlledToken, address referrer) internal {
if (address(prizeStrategy) != address(0)) {
prizeStrategy.beforeTokenMint(to, amount, controlledToken, referrer);
}
ControlledToken(controlledToken).controllerMint(to, amount);
}
/// @notice Called by the prize strategy to award external ERC721 prizes
/// @dev Used to award any arbitrary NFTs held by the Prize Pool
/// @param to The address of the winner that receives the award
/// @param externalToken The address of the external NFT token being awarded
/// @param tokenIds An array of NFT Token IDs to be transferred
function awardExternalERC721(
address to,
address externalToken,
uint256[] calldata tokenIds
)
external override
onlyPrizeStrategy
{
require(_canAwardExternal(externalToken), "PrizePool/invalid-external-token");
if (tokenIds.length == 0) {
return;
}
for (uint256 i = 0; i < tokenIds.length; i++) {
IERC721Upgradeable(externalToken).transferFrom(address(this), to, tokenIds[i]);
}
emit AwardedExternalERC721(to, externalToken, tokenIds);
}
/// @notice Calculates the reserve portion of the given amount of funds. If there is no reserve address, the portion will be zero.
/// @param amount The prize amount
/// @return The size of the reserve portion of the prize
function calculateReserveFee(uint256 amount) public view returns (uint256) {
ReserveInterface reserve = ReserveInterface(reserveRegistry.lookup());
if (address(reserve) == address(0)) {
return 0;
}
uint256 reserveRateMantissa = reserve.reserveRateMantissa(address(this));
if (reserveRateMantissa == 0) {
return 0;
}
return FixedPoint.multiplyUintByMantissa(amount, reserveRateMantissa);
}
/// @notice Sweep all timelocked balances and transfer unlocked assets to owner accounts
/// @param users An array of account addresses to sweep balances for
/// @return The total amount of assets swept from the Prize Pool
function sweepTimelockBalances(
address[] calldata users
)
external override
nonReentrant
returns (uint256)
{
return _sweepTimelockBalances(users);
}
/// @notice Sweep available timelocked balances to their owners. The full balances will be swept to the owners.
/// @param users An array of owner addresses
/// @return The total amount of assets swept from the Prize Pool
function _sweepTimelockBalances(
address[] memory users
)
internal
returns (uint256)
{
address operator = _msgSender();
uint256[] memory balances = new uint256[](users.length);
uint256 totalWithdrawal;
uint256 i;
for (i = 0; i < users.length; i++) {
address user = users[i];
if (_unlockTimestamps[user] <= _currentTime()) {
totalWithdrawal = totalWithdrawal.add(_timelockBalances[user]);
balances[i] = _timelockBalances[user];
delete _timelockBalances[user];
}
}
// if there is nothing to do, just quit
if (totalWithdrawal == 0) {
return 0;
}
timelockTotalSupply = timelockTotalSupply.sub(totalWithdrawal);
uint256 redeemed = _redeem(totalWithdrawal);
IERC20Upgradeable underlyingToken = IERC20Upgradeable(_token());
for (i = 0; i < users.length; i++) {
if (balances[i] > 0) {
delete _unlockTimestamps[users[i]];
uint256 shareMantissa = FixedPoint.calculateMantissa(balances[i], totalWithdrawal);
uint256 transferAmount = FixedPoint.multiplyUintByMantissa(redeemed, shareMantissa);
underlyingToken.safeTransfer(users[i], transferAmount);
emit TimelockedWithdrawalSwept(operator, users[i], balances[i], transferAmount);
}
}
return totalWithdrawal;
}
/// @notice Calculates a timelocked withdrawal duration and credit consumption.
/// @param from The user who is withdrawing
/// @param amount The amount the user is withdrawing
/// @param controlledToken The type of collateral the user is withdrawing (i.e. ticket or sponsorship)
/// @return durationSeconds The duration of the timelock in seconds
function calculateTimelockDuration(
address from,
address controlledToken,
uint256 amount
)
external override
returns (
uint256 durationSeconds,
uint256 burnedCredit
)
{
return _calculateTimelockDuration(from, controlledToken, amount);
}
/// @dev Calculates a timelocked withdrawal duration and credit consumption.
/// @param from The user who is withdrawing
/// @param amount The amount the user is withdrawing
/// @param controlledToken The type of collateral the user is withdrawing (i.e. ticket or sponsorship)
/// @return durationSeconds The duration of the timelock in seconds
/// @return burnedCredit The credit that was burned
function _calculateTimelockDuration(
address from,
address controlledToken,
uint256 amount
)
internal
returns (
uint256 durationSeconds,
uint256 burnedCredit
)
{
(uint256 exitFee, uint256 _burnedCredit) = _calculateEarlyExitFeeLessBurnedCredit(from, controlledToken, amount);
uint256 duration = _estimateCreditAccrualTime(controlledToken, amount, exitFee);
if (duration > maxTimelockDuration) {
duration = maxTimelockDuration;
}
return (duration, _burnedCredit);
}
/// @notice Calculates the early exit fee for the given amount
/// @param from The user who is withdrawing
/// @param controlledToken The type of collateral being withdrawn
/// @param amount The amount of collateral to be withdrawn
/// @return exitFee The exit fee
/// @return burnedCredit The user's credit that was burned
function calculateEarlyExitFee(
address from,
address controlledToken,
uint256 amount
)
external override
returns (
uint256 exitFee,
uint256 burnedCredit
)
{
return _calculateEarlyExitFeeLessBurnedCredit(from, controlledToken, amount);
}
/// @dev Calculates the early exit fee for the given amount
/// @param amount The amount of collateral to be withdrawn
/// @return Exit fee
function _calculateEarlyExitFeeNoCredit(address controlledToken, uint256 amount) internal view returns (uint256) {
return _limitExitFee(
amount,
FixedPoint.multiplyUintByMantissa(amount, _tokenCreditPlans[controlledToken].creditLimitMantissa)
);
}
/// @notice Estimates the amount of time it will take for a given amount of funds to accrue the given amount of credit.
/// @param _principal The principal amount on which interest is accruing
/// @param _interest The amount of interest that must accrue
/// @return durationSeconds The duration of time it will take to accrue the given amount of interest, in seconds.
function estimateCreditAccrualTime(
address _controlledToken,
uint256 _principal,
uint256 _interest
)
external override
view
returns (uint256 durationSeconds)
{
return _estimateCreditAccrualTime(
_controlledToken,
_principal,
_interest
);
}
/// @notice Estimates the amount of time it will take for a given amount of funds to accrue the given amount of credit
/// @param _principal The principal amount on which interest is accruing
/// @param _interest The amount of interest that must accrue
/// @return durationSeconds The duration of time it will take to accrue the given amount of interest, in seconds.
function _estimateCreditAccrualTime(
address _controlledToken,
uint256 _principal,
uint256 _interest
)
internal
view
returns (uint256 durationSeconds)
{
// interest = credit rate * principal * time
// => time = interest / (credit rate * principal)
uint256 accruedPerSecond = FixedPoint.multiplyUintByMantissa(_principal, _tokenCreditPlans[_controlledToken].creditRateMantissa);
if (accruedPerSecond == 0) {
return 0;
}
return _interest.div(accruedPerSecond);
}
/// @notice Burns a users credit.
/// @param user The user whose credit should be burned
/// @param credit The amount of credit to burn
function _burnCredit(address user, address controlledToken, uint256 credit) internal {
_tokenCreditBalances[controlledToken][user].balance = uint256(_tokenCreditBalances[controlledToken][user].balance).sub(credit).toUint128();
emit CreditBurned(user, controlledToken, credit);
}
/// @notice Accrues ticket credit for a user assuming their current balance is the passed balance. May burn credit if they exceed their limit.
/// @param user The user for whom to accrue credit
/// @param controlledToken The controlled token whose balance we are checking
/// @param controlledTokenBalance The balance to use for the user
/// @param extra Additional credit to be added
function _accrueCredit(address user, address controlledToken, uint256 controlledTokenBalance, uint256 extra) internal {
_updateCreditBalance(
user,
controlledToken,
_calculateCreditBalance(user, controlledToken, controlledTokenBalance, extra)
);
}
function _calculateCreditBalance(address user, address controlledToken, uint256 controlledTokenBalance, uint256 extra) internal view returns (uint256) {
uint256 newBalance;
CreditBalance storage creditBalance = _tokenCreditBalances[controlledToken][user];
if (!creditBalance.initialized) {
newBalance = 0;
} else {
uint256 credit = _calculateAccruedCredit(user, controlledToken, controlledTokenBalance);
newBalance = _applyCreditLimit(controlledToken, controlledTokenBalance, uint256(creditBalance.balance).add(credit).add(extra));
}
return newBalance;
}
function _updateCreditBalance(address user, address controlledToken, uint256 newBalance) internal {
uint256 oldBalance = _tokenCreditBalances[controlledToken][user].balance;
_tokenCreditBalances[controlledToken][user] = CreditBalance({
balance: newBalance.toUint128(),
timestamp: _currentTime().toUint32(),
initialized: true
});
if (oldBalance < newBalance) {
emit CreditMinted(user, controlledToken, newBalance.sub(oldBalance));
} else {
emit CreditBurned(user, controlledToken, oldBalance.sub(newBalance));
}
}
/// @notice Applies the credit limit to a credit balance. The balance cannot exceed the credit limit.
/// @param controlledToken The controlled token that the user holds
/// @param controlledTokenBalance The users ticket balance (used to calculate credit limit)
/// @param creditBalance The new credit balance to be checked
/// @return The users new credit balance. Will not exceed the credit limit.
function _applyCreditLimit(address controlledToken, uint256 controlledTokenBalance, uint256 creditBalance) internal view returns (uint256) {
uint256 creditLimit = FixedPoint.multiplyUintByMantissa(
controlledTokenBalance,
_tokenCreditPlans[controlledToken].creditLimitMantissa
);
if (creditBalance > creditLimit) {
creditBalance = creditLimit;
}
return creditBalance;
}
/// @notice Calculates the accrued interest for a user
/// @param user The user whose credit should be calculated.
/// @param controlledToken The controlled token that the user holds
/// @param controlledTokenBalance The user's current balance of the controlled tokens.
/// @return The credit that has accrued since the last credit update.
function _calculateAccruedCredit(address user, address controlledToken, uint256 controlledTokenBalance) internal view returns (uint256) {
uint256 userTimestamp = _tokenCreditBalances[controlledToken][user].timestamp;
if (!_tokenCreditBalances[controlledToken][user].initialized) {
return 0;
}
uint256 deltaTime = _currentTime().sub(userTimestamp);
uint256 creditPerSecond = FixedPoint.multiplyUintByMantissa(controlledTokenBalance, _tokenCreditPlans[controlledToken].creditRateMantissa);
return deltaTime.mul(creditPerSecond);
}
/// @notice Returns the credit balance for a given user. Not that this includes both minted credit and pending credit.
/// @param user The user whose credit balance should be returned
/// @return The balance of the users credit
function balanceOfCredit(address user, address controlledToken) external override onlyControlledToken(controlledToken) returns (uint256) {
_accrueCredit(user, controlledToken, IERC20Upgradeable(controlledToken).balanceOf(user), 0);
return _tokenCreditBalances[controlledToken][user].balance;
}
/// @notice Sets the rate at which credit accrues per second. The credit rate is a fixed point 18 number (like Ether).
/// @param _controlledToken The controlled token for whom to set the credit plan
/// @param _creditRateMantissa The credit rate to set. Is a fixed point 18 decimal (like Ether).
/// @param _creditLimitMantissa The credit limit to set. Is a fixed point 18 decimal (like Ether).
function setCreditPlanOf(
address _controlledToken,
uint128 _creditRateMantissa,
uint128 _creditLimitMantissa
)
external override
onlyControlledToken(_controlledToken)
onlyOwner
{
_tokenCreditPlans[_controlledToken] = CreditPlan({
creditLimitMantissa: _creditLimitMantissa,
creditRateMantissa: _creditRateMantissa
});
emit CreditPlanSet(_controlledToken, _creditLimitMantissa, _creditRateMantissa);
}
/// @notice Returns the credit rate of a controlled token
/// @param controlledToken The controlled token to retrieve the credit rates for
/// @return creditLimitMantissa The credit limit fraction. This number is used to calculate both the credit limit and early exit fee.
/// @return creditRateMantissa The credit rate. This is the amount of tokens that accrue per second.
function creditPlanOf(
address controlledToken
)
external override
view
returns (
uint128 creditLimitMantissa,
uint128 creditRateMantissa
)
{
creditLimitMantissa = _tokenCreditPlans[controlledToken].creditLimitMantissa;
creditRateMantissa = _tokenCreditPlans[controlledToken].creditRateMantissa;
}
/// @notice Calculate the early exit for a user given a withdrawal amount. The user's credit is taken into account.
/// @param from The user who is withdrawing
/// @param controlledToken The token they are withdrawing
/// @param amount The amount of funds they are withdrawing
/// @return earlyExitFee The additional exit fee that should be charged.
/// @return creditBurned The amount of credit that will be burned
function _calculateEarlyExitFeeLessBurnedCredit(
address from,
address controlledToken,
uint256 amount
)
internal
returns (
uint256 earlyExitFee,
uint256 creditBurned
)
{
uint256 controlledTokenBalance = IERC20Upgradeable(controlledToken).balanceOf(from);
require(controlledTokenBalance >= amount, "PrizePool/insuff-funds");
_accrueCredit(from, controlledToken, controlledTokenBalance, 0);
/*
The credit is used *last*. Always charge the fees up-front.
How to calculate:
Calculate their remaining exit fee. I.e. full exit fee of their balance less their credit.
If the exit fee on their withdrawal is greater than the remaining exit fee, then they'll have to pay the difference.
*/
// Determine available usable credit based on withdraw amount
uint256 remainingExitFee = _calculateEarlyExitFeeNoCredit(controlledToken, controlledTokenBalance.sub(amount));
uint256 availableCredit;
if (_tokenCreditBalances[controlledToken][from].balance >= remainingExitFee) {
availableCredit = uint256(_tokenCreditBalances[controlledToken][from].balance).sub(remainingExitFee);
}
// Determine amount of credit to burn and amount of fees required
uint256 totalExitFee = _calculateEarlyExitFeeNoCredit(controlledToken, amount);
creditBurned = (availableCredit > totalExitFee) ? totalExitFee : availableCredit;
earlyExitFee = totalExitFee.sub(creditBurned);
return (earlyExitFee, creditBurned);
}
/// @notice Allows the Governor to set a cap on the amount of liquidity that he pool can hold
/// @param _liquidityCap The new liquidity cap for the prize pool
function setLiquidityCap(uint256 _liquidityCap) external override onlyOwner {
_setLiquidityCap(_liquidityCap);
}
function _setLiquidityCap(uint256 _liquidityCap) internal {
liquidityCap = _liquidityCap;
emit LiquidityCapSet(_liquidityCap);
}
/// @notice Allows the Governor to add Controlled Tokens to the Prize Pool
/// @param _controlledToken The address of the Controlled Token to add
function addControlledToken(ControlledTokenInterface _controlledToken) external override onlyOwner {
_addControlledToken(_controlledToken);
}
/// @notice Adds a new controlled token
/// @param _controlledToken The controlled token to add. Cannot be a duplicate.
function _addControlledToken(ControlledTokenInterface _controlledToken) internal {
require(_controlledToken.controller() == this, "PrizePool/token-ctrlr-mismatch");
_tokens.addAddress(address(_controlledToken));
emit ControlledTokenAdded(_controlledToken);
}
/// @notice Sets the prize strategy of the prize pool. Only callable by the owner.
/// @param _prizeStrategy The new prize strategy
function setPrizeStrategy(TokenListenerInterface _prizeStrategy) external override onlyOwner {
_setPrizeStrategy(_prizeStrategy);
}
/// @notice Sets the prize strategy of the prize pool. Only callable by the owner.
/// @param _prizeStrategy The new prize strategy
function _setPrizeStrategy(TokenListenerInterface _prizeStrategy) internal {
require(address(_prizeStrategy) != address(0), "PrizePool/prizeStrategy-not-zero");
require(address(_prizeStrategy).supportsInterface(TokenListenerLibrary.ERC165_INTERFACE_ID_TOKEN_LISTENER), "PrizePool/prizeStrategy-invalid");
prizeStrategy = _prizeStrategy;
emit PrizeStrategySet(address(_prizeStrategy));
}
/// @notice An array of the Tokens controlled by the Prize Pool (ie. Tickets, Sponsorship)
/// @return An array of controlled token addresses
function tokens() external override view returns (address[] memory) {
return _tokens.addressArray();
}
/// @dev Gets the current time as represented by the current block
/// @return The timestamp of the current block
function _currentTime() internal virtual view returns (uint256) {
return block.timestamp;
}
/// @notice The timestamp at which an account's timelocked balance will be made available to sweep
/// @param user The address of an account with timelocked assets
/// @return The timestamp at which the locked assets will be made available
function timelockBalanceAvailableAt(address user) external override view returns (uint256) {
return _unlockTimestamps[user];
}
/// @notice The balance of timelocked assets for an account
/// @param user The address of an account with timelocked assets
/// @return The amount of assets that have been timelocked
function timelockBalanceOf(address user) external override view returns (uint256) {
return _timelockBalances[user];
}
/// @notice The total of all controlled tokens and timelock.
/// @return The current total of all tokens and timelock.
function accountedBalance() external override view returns (uint256) {
return _tokenTotalSupply();
}
/// @notice The total of all controlled tokens and timelock.
/// @return The current total of all tokens and timelock.
function _tokenTotalSupply() internal view returns (uint256) {
uint256 total = timelockTotalSupply.add(reserveTotalSupply);
address currentToken = _tokens.start();
while (currentToken != address(0) && currentToken != _tokens.end()) {
total = total.add(IERC20Upgradeable(currentToken).totalSupply());
currentToken = _tokens.next(currentToken);
}
return total;
}
/// @dev Checks if the Prize Pool can receive liquidity based on the current cap
/// @param _amount The amount of liquidity to be added to the Prize Pool
/// @return True if the Prize Pool can receive the specified amount of liquidity
function _canAddLiquidity(uint256 _amount) internal view returns (bool) {
uint256 tokenTotalSupply = _tokenTotalSupply();
return (tokenTotalSupply.add(_amount) <= liquidityCap);
}
/// @dev Checks if a specific token is controlled by the Prize Pool
/// @param controlledToken The address of the token to check
/// @return True if the token is a controlled token, false otherwise
function _isControlled(address controlledToken) internal view returns (bool) {
return _tokens.contains(controlledToken);
}
/// @dev Function modifier to ensure usage of tokens controlled by the Prize Pool
/// @param controlledToken The address of the token to check
modifier onlyControlledToken(address controlledToken) {
require(_isControlled(controlledToken), "PrizePool/unknown-token");
_;
}
/// @dev Function modifier to ensure caller is the prize-strategy
modifier onlyPrizeStrategy() {
require(_msgSender() == address(prizeStrategy), "PrizePool/only-prizeStrategy");
_;
}
/// @dev Function modifier to ensure the deposit amount does not exceed the liquidity cap (if set)
modifier canAddLiquidity(uint256 _amount) {
require(_canAddLiquidity(_amount), "PrizePool/exceeds-liquidity-cap");
_;
}
modifier onlyReserve() {
ReserveInterface reserve = ReserveInterface(reserveRegistry.lookup());
require(address(reserve) == msg.sender, "PrizePool/only-reserve");
_;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../GSN/ContextUpgradeable.sol";
import "../proxy/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../proxy/Initializable.sol";
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
// solhint-disable-next-line compiler-version
pragma solidity >=0.4.24 <0.8.0;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Modifier to protect an initializer function from being invoked twice.
*/
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
// solhint-disable-next-line no-inline-assembly
assembly { cs := extcodesize(self) }
return cs == 0;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*
* Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
* all math on `uint256` and `int256` and then downcasting.
*/
library SafeCastUpgradeable {
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
return uint128(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
return uint64(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
return uint32(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits.
*/
function toUint8(uint256 value) internal pure returns (uint8) {
require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v3.1._
*/
function toInt128(int256 value) internal pure returns (int128) {
require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits");
return int128(value);
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v3.1._
*/
function toInt64(int256 value) internal pure returns (int64) {
require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits");
return int64(value);
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v3.1._
*/
function toInt32(int256 value) internal pure returns (int32) {
require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits");
return int32(value);
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v3.1._
*/
function toInt16(int256 value) internal pure returns (int16) {
require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits");
return int16(value);
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits.
*
* _Available since v3.1._
*/
function toInt8(int256 value) internal pure returns (int8) {
require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits");
return int8(value);
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
require(value < 2**255, "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../proxy/Initializable.sol";
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal initializer {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal initializer {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.8.0;
import "../../introspection/IERC165Upgradeable.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721Upgradeable is IERC165Upgradeable {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165Upgradeable {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.8.0;
/**
* @dev Library used to query support of an interface declared via {IERC165}.
*
* Note that these functions return the actual result of the query: they do not
* `revert` if an interface is not supported. It is up to the caller to decide
* what to do in these cases.
*/
library ERC165CheckerUpgradeable {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* @dev Returns true if `account` supports the {IERC165} interface,
*/
function supportsERC165(address account) internal view returns (bool) {
// Any contract that implements ERC165 must explicitly indicate support of
// InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
return _supportsERC165Interface(account, _INTERFACE_ID_ERC165) &&
!_supportsERC165Interface(account, _INTERFACE_ID_INVALID);
}
/**
* @dev Returns true if `account` supports the interface defined by
* `interfaceId`. Support for {IERC165} itself is queried automatically.
*
* See {IERC165-supportsInterface}.
*/
function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
// query support of both ERC165 as per the spec and support of _interfaceId
return supportsERC165(account) &&
_supportsERC165Interface(account, interfaceId);
}
/**
* @dev Returns true if `account` supports all the interfaces defined in
* `interfaceIds`. Support for {IERC165} itself is queried automatically.
*
* Batch-querying can lead to gas savings by skipping repeated checks for
* {IERC165} support.
*
* See {IERC165-supportsInterface}.
*/
function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
// query support of ERC165 itself
if (!supportsERC165(account)) {
return false;
}
// query support of each interface in _interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!_supportsERC165Interface(account, interfaceIds[i])) {
return false;
}
}
// all interfaces supported
return true;
}
/**
* @notice Query if a contract implements an interface, does not check ERC165 support
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return true if the contract at account indicates support of the interface with
* identifier interfaceId, false otherwise
* @dev Assumes that account contains a contract that supports ERC165, otherwise
* the behavior of this method is undefined. This precondition can be checked
* with {supportsERC165}.
* Interface identification is specified in ERC-165.
*/
function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {
// success determines whether the staticcall succeeded and result determines
// whether the contract at account indicates support of _interfaceId
(bool success, bool result) = _callERC165SupportsInterface(account, interfaceId);
return (success && result);
}
/**
* @notice Calls the function with selector 0x01ffc9a7 (ERC165) and suppresses throw
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return success true if the STATICCALL succeeded, false otherwise
* @return result true if the STATICCALL succeeded and the contract at account
* indicates support of the interface with identifier interfaceId, false otherwise
*/
function _callERC165SupportsInterface(address account, bytes4 interfaceId)
private
view
returns (bool, bool)
{
bytes memory encodedParams = abi.encodeWithSelector(_INTERFACE_ID_ERC165, interfaceId);
(bool success, bytes memory result) = account.staticcall{ gas: 30000 }(encodedParams);
if (result.length < 32) return (false, false);
return (success, abi.decode(result, (bool)));
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "./IERC20Upgradeable.sol";
import "../../math/SafeMathUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20Upgradeable {
using SafeMathUpgradeable for uint256;
using AddressUpgradeable for address;
function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20Upgradeable {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMathUpgradeable {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
/**
Copyright 2020 PoolTogether Inc.
This file is part of PoolTogether.
PoolTogether is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation under version 3 of the License.
PoolTogether is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with PoolTogether. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.0 <0.8.0;
import "./external/openzeppelin/OpenZeppelinSafeMath_V3_3_0.sol";
/**
* @author Brendan Asselstine
* @notice Provides basic fixed point math calculations.
*
* This library calculates integer fractions by scaling values by 1e18 then performing standard integer math.
*/
library FixedPoint {
using OpenZeppelinSafeMath_V3_3_0 for uint256;
// The scale to use for fixed point numbers. Same as Ether for simplicity.
uint256 internal constant SCALE = 1e18;
/**
* Calculates a Fixed18 mantissa given the numerator and denominator
*
* The mantissa = (numerator * 1e18) / denominator
*
* @param numerator The mantissa numerator
* @param denominator The mantissa denominator
* @return The mantissa of the fraction
*/
function calculateMantissa(uint256 numerator, uint256 denominator) internal pure returns (uint256) {
uint256 mantissa = numerator.mul(SCALE);
mantissa = mantissa.div(denominator);
return mantissa;
}
/**
* Multiplies a Fixed18 number by an integer.
*
* @param b The whole integer to multiply
* @param mantissa The Fixed18 number
* @return An integer that is the result of multiplying the params.
*/
function multiplyUintByMantissa(uint256 b, uint256 mantissa) internal pure returns (uint256) {
uint256 result = mantissa.mul(b);
result = result.div(SCALE);
return result;
}
/**
* Divides an integer by a fixed point 18 mantissa
*
* @param dividend The integer to divide
* @param mantissa The fixed point 18 number to serve as the divisor
* @return An integer that is the result of dividing an integer by a fixed point 18 mantissa
*/
function divideUintByMantissa(uint256 dividend, uint256 mantissa) internal pure returns (uint256) {
uint256 result = SCALE.mul(dividend);
result = result.div(mantissa);
return result;
}
}
// SPDX-License-Identifier: MIT
// NOTE: Copied from OpenZeppelin Contracts version 3.3.0
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library OpenZeppelinSafeMath_V3_3_0 {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;
/// @title Interface that allows a user to draw an address using an index
interface RegistryInterface {
function lookup() external view returns (address);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;
/// @title Interface that allows a user to draw an address using an index
interface ReserveInterface {
function reserveRateMantissa(address prizePool) external view returns (uint256);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
/// @title Defines the functions used to interact with a yield source. The Prize Pool inherits this contract.
/// @notice Prize Pools subclasses need to implement this interface so that yield can be generated.
abstract contract YieldSource {
/// @notice Determines whether the passed token can be transferred out as an external award.
/// @dev Different yield sources will hold the deposits as another kind of token: such a Compound's cToken. The
/// prize strategy should not be allowed to move those tokens.
/// @param _externalToken The address of the token to check
/// @return True if the token may be awarded, false otherwise
function _canAwardExternal(address _externalToken) internal virtual view returns (bool);
/// @notice Returns the ERC20 asset token used for deposits.
/// @return The ERC20 asset token
function _token() internal virtual view returns (IERC20Upgradeable);
/// @notice Returns the total balance (in asset tokens). This includes the deposits and interest.
/// @return The underlying balance of asset tokens
function _balance() internal virtual returns (uint256);
/// @notice Supplies asset tokens to the yield source.
/// @param mintAmount The amount of asset tokens to be supplied
function _supply(uint256 mintAmount) internal virtual;
/// @notice Redeems asset tokens from the yield source.
/// @param redeemAmount The amount of yield-bearing tokens to be redeemed
/// @return The actual amount of tokens that were redeemed.
function _redeem(uint256 redeemAmount) internal virtual returns (uint256);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/introspection/IERC165Upgradeable.sol";
/// @title An interface that allows a contract to listen to token mint, transfer and burn events.
interface TokenListenerInterface is IERC165Upgradeable {
/// @notice Called when tokens are minted.
/// @param to The address of the receiver of the minted tokens.
/// @param amount The amount of tokens being minted
/// @param controlledToken The address of the token that is being minted
/// @param referrer The address that referred the minting.
function beforeTokenMint(address to, uint256 amount, address controlledToken, address referrer) external;
/// @notice Called when tokens are transferred or burned.
/// @param from The address of the sender of the token transfer
/// @param to The address of the receiver of the token transfer. Will be the zero address if burning.
/// @param amount The amount of tokens transferred
/// @param controlledToken The address of the token that was transferred
function beforeTokenTransfer(address from, address to, uint256 amount, address controlledToken) external;
}
pragma solidity ^0.6.12;
library TokenListenerLibrary {
/*
* bytes4(keccak256('beforeTokenMint(address,uint256,address,address)')) == 0x4d7f3db0
* bytes4(keccak256('beforeTokenTransfer(address,address,uint256,address)')) == 0xb2210957
*
* => 0x4d7f3db0 ^ 0xb2210957 == 0xff5e34e7
*/
bytes4 public constant ERC165_INTERFACE_ID_TOKEN_LISTENER = 0xff5e34e7;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "./TokenControllerInterface.sol";
import "./ControlledTokenInterface.sol";
/// @title Controlled ERC20 Token
/// @notice ERC20 Tokens with a controller for minting & burning
contract ControlledToken is ERC20Upgradeable, ControlledTokenInterface {
/// @notice Interface to the contract responsible for controlling mint/burn
TokenControllerInterface public override controller;
/// @notice Initializes the Controlled Token with Token Details and the Controller
/// @param _name The name of the Token
/// @param _symbol The symbol for the Token
/// @param _decimals The number of decimals for the Token
/// @param _controller Address of the Controller contract for minting & burning
function initialize(
string memory _name,
string memory _symbol,
uint8 _decimals,
TokenControllerInterface _controller
)
public
virtual
initializer
{
__ERC20_init(_name, _symbol);
controller = _controller;
_setupDecimals(_decimals);
}
/// @notice Allows the controller to mint tokens for a user account
/// @dev May be overridden to provide more granular control over minting
/// @param _user Address of the receiver of the minted tokens
/// @param _amount Amount of tokens to mint
function controllerMint(address _user, uint256 _amount) external virtual override onlyController {
_mint(_user, _amount);
}
/// @notice Allows the controller to burn tokens from a user account
/// @dev May be overridden to provide more granular control over burning
/// @param _user Address of the holder account to burn tokens from
/// @param _amount Amount of tokens to burn
function controllerBurn(address _user, uint256 _amount) external virtual override onlyController {
_burn(_user, _amount);
}
/// @notice Allows an operator via the controller to burn tokens on behalf of a user account
/// @dev May be overridden to provide more granular control over operator-burning
/// @param _operator Address of the operator performing the burn action via the controller contract
/// @param _user Address of the holder account to burn tokens from
/// @param _amount Amount of tokens to burn
function controllerBurnFrom(address _operator, address _user, uint256 _amount) external virtual override onlyController {
if (_operator != _user) {
uint256 decreasedAllowance = allowance(_user, _operator).sub(_amount, "ControlledToken/exceeds-allowance");
_approve(_user, _operator, decreasedAllowance);
}
_burn(_user, _amount);
}
/// @dev Function modifier to ensure that the caller is the controller contract
modifier onlyController {
require(_msgSender() == address(controller), "ControlledToken/only-controller");
_;
}
/// @dev Controller hook to provide notifications & rule validations on token transfers to the controller.
/// This includes minting and burning.
/// May be overridden to provide more granular control over operator-burning
/// @param from Address of the account sending the tokens (address(0x0) on minting)
/// @param to Address of the account receiving the tokens (address(0x0) on burning)
/// @param amount Amount of tokens being transferred
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
controller.beforeTokenTransfer(from, to, amount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../../GSN/ContextUpgradeable.sol";
import "./IERC20Upgradeable.sol";
import "../../math/SafeMathUpgradeable.sol";
import "../../proxy/Initializable.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable {
using SafeMathUpgradeable for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
function __ERC20_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
uint256[44] private __gap;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;
/// @title Controlled ERC20 Token Interface
/// @notice Required interface for Controlled ERC20 Tokens linked to a Prize Pool
/// @dev Defines the spec required to be implemented by a Controlled ERC20 Token
interface TokenControllerInterface {
/// @dev Controller hook to provide notifications & rule validations on token transfers to the controller.
/// This includes minting and burning.
/// @param from Address of the account sending the tokens (address(0x0) on minting)
/// @param to Address of the account receiving the tokens (address(0x0) on burning)
/// @param amount Amount of tokens being transferred
function beforeTokenTransfer(address from, address to, uint256 amount) external;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "./TokenControllerInterface.sol";
/// @title Controlled ERC20 Token
/// @notice ERC20 Tokens with a controller for minting & burning
interface ControlledTokenInterface is IERC20Upgradeable {
/// @notice Interface to the contract responsible for controlling mint/burn
function controller() external view returns (TokenControllerInterface);
/// @notice Allows the controller to mint tokens for a user account
/// @dev May be overridden to provide more granular control over minting
/// @param _user Address of the receiver of the minted tokens
/// @param _amount Amount of tokens to mint
function controllerMint(address _user, uint256 _amount) external;
/// @notice Allows the controller to burn tokens from a user account
/// @dev May be overridden to provide more granular control over burning
/// @param _user Address of the holder account to burn tokens from
/// @param _amount Amount of tokens to burn
function controllerBurn(address _user, uint256 _amount) external;
/// @notice Allows an operator via the controller to burn tokens on behalf of a user account
/// @dev May be overridden to provide more granular control over operator-burning
/// @param _operator Address of the operator performing the burn action via the controller contract
/// @param _user Address of the holder account to burn tokens from
/// @param _amount Amount of tokens to burn
function controllerBurnFrom(address _operator, address _user, uint256 _amount) external;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
/// @notice An efficient implementation of a singly linked list of addresses
/// @dev A mapping(address => address) tracks the 'next' pointer. A special address called the SENTINEL is used to denote the beginning and end of the list.
library MappedSinglyLinkedList {
/// @notice The special value address used to denote the end of the list
address public constant SENTINEL = address(0x1);
/// @notice The data structure to use for the list.
struct Mapping {
uint256 count;
mapping(address => address) addressMap;
}
/// @notice Initializes the list.
/// @dev It is important that this is called so that the SENTINEL is correctly setup.
function initialize(Mapping storage self) internal {
require(self.count == 0, "Already init");
self.addressMap[SENTINEL] = SENTINEL;
}
function start(Mapping storage self) internal view returns (address) {
return self.addressMap[SENTINEL];
}
function next(Mapping storage self, address current) internal view returns (address) {
return self.addressMap[current];
}
function end(Mapping storage) internal pure returns (address) {
return SENTINEL;
}
function addAddresses(Mapping storage self, address[] memory addresses) internal {
for (uint256 i = 0; i < addresses.length; i++) {
addAddress(self, addresses[i]);
}
}
/// @notice Adds an address to the front of the list.
/// @param self The Mapping struct that this function is attached to
/// @param newAddress The address to shift to the front of the list
function addAddress(Mapping storage self, address newAddress) internal {
require(newAddress != SENTINEL && newAddress != address(0), "Invalid address");
require(self.addressMap[newAddress] == address(0), "Already added");
self.addressMap[newAddress] = self.addressMap[SENTINEL];
self.addressMap[SENTINEL] = newAddress;
self.count = self.count + 1;
}
/// @notice Removes an address from the list
/// @param self The Mapping struct that this function is attached to
/// @param prevAddress The address that precedes the address to be removed. This may be the SENTINEL if at the start.
/// @param addr The address to remove from the list.
function removeAddress(Mapping storage self, address prevAddress, address addr) internal {
require(addr != SENTINEL && addr != address(0), "Invalid address");
require(self.addressMap[prevAddress] == addr, "Invalid prevAddress");
self.addressMap[prevAddress] = self.addressMap[addr];
delete self.addressMap[addr];
self.count = self.count - 1;
}
/// @notice Determines whether the list contains the given address
/// @param self The Mapping struct that this function is attached to
/// @param addr The address to check
/// @return True if the address is contained, false otherwise.
function contains(Mapping storage self, address addr) internal view returns (bool) {
return addr != SENTINEL && addr != address(0) && self.addressMap[addr] != address(0);
}
/// @notice Returns an address array of all the addresses in this list
/// @dev Contains a for loop, so complexity is O(n) wrt the list size
/// @param self The Mapping struct that this function is attached to
/// @return An array of all the addresses
function addressArray(Mapping storage self) internal view returns (address[] memory) {
address[] memory array = new address[](self.count);
uint256 count;
address currentAddress = self.addressMap[SENTINEL];
while (currentAddress != address(0) && currentAddress != SENTINEL) {
array[count] = currentAddress;
currentAddress = self.addressMap[currentAddress];
count++;
}
return array;
}
/// @notice Removes every address from the list
/// @param self The Mapping struct that this function is attached to
function clearAll(Mapping storage self) internal {
address currentAddress = self.addressMap[SENTINEL];
while (currentAddress != address(0) && currentAddress != SENTINEL) {
address nextAddress = self.addressMap[currentAddress];
delete self.addressMap[currentAddress];
currentAddress = nextAddress;
}
self.addressMap[SENTINEL] = SENTINEL;
self.count = 0;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "../token/TokenListenerInterface.sol";
import "../token/ControlledTokenInterface.sol";
/// @title Escrows assets and deposits them into a yield source. Exposes interest to Prize Strategy. Users deposit and withdraw from this contract to participate in Prize Pool.
/// @notice Accounting is managed using Controlled Tokens, whose mint and burn functions can only be called by this contract.
/// @dev Must be inherited to provide specific yield-bearing asset control, such as Compound cTokens
interface PrizePoolInterface {
/// @notice Deposit assets into the Prize Pool in exchange for tokens
/// @param to The address receiving the newly minted tokens
/// @param amount The amount of assets to deposit
/// @param controlledToken The address of the type of token the user is minting
/// @param referrer The referrer of the deposit
function depositTo(
address to,
uint256 amount,
address controlledToken,
address referrer
)
external;
/// @notice Withdraw assets from the Prize Pool instantly. A fairness fee may be charged for an early exit.
/// @param from The address to redeem tokens from.
/// @param amount The amount of tokens to redeem for assets.
/// @param controlledToken The address of the token to redeem (i.e. ticket or sponsorship)
/// @param maximumExitFee The maximum exit fee the caller is willing to pay. This should be pre-calculated by the calculateExitFee() fxn.
/// @return The actual exit fee paid
function withdrawInstantlyFrom(
address from,
uint256 amount,
address controlledToken,
uint256 maximumExitFee
) external returns (uint256);
/// @notice Withdraw assets from the Prize Pool by placing them into the timelock.
/// The timelock is used to ensure that the tickets have contributed their fair share of the prize.
/// @dev Note that if the user has previously timelocked funds then this contract will try to sweep them.
/// If the existing timelocked funds are still locked, then the incoming
/// balance is added to their existing balance and the new timelock unlock timestamp will overwrite the old one.
/// @param from The address to withdraw from
/// @param amount The amount to withdraw
/// @param controlledToken The type of token being withdrawn
/// @return The timestamp from which the funds can be swept
function withdrawWithTimelockFrom(
address from,
uint256 amount,
address controlledToken
) external returns (uint256);
function withdrawReserve(address to) external returns (uint256);
/// @notice Returns the balance that is available to award.
/// @dev captureAwardBalance() should be called first
/// @return The total amount of assets to be awarded for the current prize
function awardBalance() external view returns (uint256);
/// @notice Captures any available interest as award balance.
/// @dev This function also captures the reserve fees.
/// @return The total amount of assets to be awarded for the current prize
function captureAwardBalance() external returns (uint256);
/// @notice Called by the prize strategy to award prizes.
/// @dev The amount awarded must be less than the awardBalance()
/// @param to The address of the winner that receives the award
/// @param amount The amount of assets to be awarded
/// @param controlledToken The address of the asset token being awarded
function award(
address to,
uint256 amount,
address controlledToken
)
external;
/// @notice Called by the Prize-Strategy to transfer out external ERC20 tokens
/// @dev Used to transfer out tokens held by the Prize Pool. Could be liquidated, or anything.
/// @param to The address of the winner that receives the award
/// @param amount The amount of external assets to be awarded
/// @param externalToken The address of the external asset token being awarded
function transferExternalERC20(
address to,
address externalToken,
uint256 amount
)
external;
/// @notice Called by the Prize-Strategy to award external ERC20 prizes
/// @dev Used to award any arbitrary tokens held by the Prize Pool
/// @param to The address of the winner that receives the award
/// @param amount The amount of external assets to be awarded
/// @param externalToken The address of the external asset token being awarded
function awardExternalERC20(
address to,
address externalToken,
uint256 amount
)
external;
/// @notice Called by the prize strategy to award external ERC721 prizes
/// @dev Used to award any arbitrary NFTs held by the Prize Pool
/// @param to The address of the winner that receives the award
/// @param externalToken The address of the external NFT token being awarded
/// @param tokenIds An array of NFT Token IDs to be transferred
function awardExternalERC721(
address to,
address externalToken,
uint256[] calldata tokenIds
)
external;
/// @notice Sweep all timelocked balances and transfer unlocked assets to owner accounts
/// @param users An array of account addresses to sweep balances for
/// @return The total amount of assets swept from the Prize Pool
function sweepTimelockBalances(
address[] calldata users
)
external
returns (uint256);
/// @notice Calculates a timelocked withdrawal duration and credit consumption.
/// @param from The user who is withdrawing
/// @param amount The amount the user is withdrawing
/// @param controlledToken The type of collateral the user is withdrawing (i.e. ticket or sponsorship)
/// @return durationSeconds The duration of the timelock in seconds
function calculateTimelockDuration(
address from,
address controlledToken,
uint256 amount
)
external
returns (
uint256 durationSeconds,
uint256 burnedCredit
);
/// @notice Calculates the early exit fee for the given amount
/// @param from The user who is withdrawing
/// @param controlledToken The type of collateral being withdrawn
/// @param amount The amount of collateral to be withdrawn
/// @return exitFee The exit fee
/// @return burnedCredit The user's credit that was burned
function calculateEarlyExitFee(
address from,
address controlledToken,
uint256 amount
)
external
returns (
uint256 exitFee,
uint256 burnedCredit
);
/// @notice Estimates the amount of time it will take for a given amount of funds to accrue the given amount of credit.
/// @param _principal The principal amount on which interest is accruing
/// @param _interest The amount of interest that must accrue
/// @return durationSeconds The duration of time it will take to accrue the given amount of interest, in seconds.
function estimateCreditAccrualTime(
address _controlledToken,
uint256 _principal,
uint256 _interest
)
external
view
returns (uint256 durationSeconds);
/// @notice Returns the credit balance for a given user. Not that this includes both minted credit and pending credit.
/// @param user The user whose credit balance should be returned
/// @return The balance of the users credit
function balanceOfCredit(address user, address controlledToken) external returns (uint256);
/// @notice Sets the rate at which credit accrues per second. The credit rate is a fixed point 18 number (like Ether).
/// @param _controlledToken The controlled token for whom to set the credit plan
/// @param _creditRateMantissa The credit rate to set. Is a fixed point 18 decimal (like Ether).
/// @param _creditLimitMantissa The credit limit to set. Is a fixed point 18 decimal (like Ether).
function setCreditPlanOf(
address _controlledToken,
uint128 _creditRateMantissa,
uint128 _creditLimitMantissa
)
external;
/// @notice Returns the credit rate of a controlled token
/// @param controlledToken The controlled token to retrieve the credit rates for
/// @return creditLimitMantissa The credit limit fraction. This number is used to calculate both the credit limit and early exit fee.
/// @return creditRateMantissa The credit rate. This is the amount of tokens that accrue per second.
function creditPlanOf(
address controlledToken
)
external
view
returns (
uint128 creditLimitMantissa,
uint128 creditRateMantissa
);
/// @notice Allows the Governor to set a cap on the amount of liquidity that he pool can hold
/// @param _liquidityCap The new liquidity cap for the prize pool
function setLiquidityCap(uint256 _liquidityCap) external;
/// @notice Allows the Governor to add Controlled Tokens to the Prize Pool
/// @param _controlledToken The address of the Controlled Token to add
function addControlledToken(ControlledTokenInterface _controlledToken) external;
/// @notice Sets the prize strategy of the prize pool. Only callable by the owner.
/// @param _prizeStrategy The new prize strategy. Must implement TokenListenerInterface
function setPrizeStrategy(TokenListenerInterface _prizeStrategy) external;
/// @dev Returns the address of the underlying ERC20 asset
/// @return The address of the asset
function token() external view returns (address);
/// @notice An array of the Tokens controlled by the Prize Pool (ie. Tickets, Sponsorship)
/// @return An array of controlled token addresses
function tokens() external view returns (address[] memory);
/// @notice The timestamp at which an account's timelocked balance will be made available to sweep
/// @param user The address of an account with timelocked assets
/// @return The timestamp at which the locked assets will be made available
function timelockBalanceAvailableAt(address user) external view returns (uint256);
/// @notice The balance of timelocked assets for an account
/// @param user The address of an account with timelocked assets
/// @return The amount of assets that have been timelocked
function timelockBalanceOf(address user) external view returns (uint256);
/// @notice The total of all controlled tokens and timelock.
/// @return The current total of all tokens and timelock.
function accountedBalance() external view returns (uint256);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/SafeCastUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/introspection/ERC165CheckerUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@pooltogether/pooltogether-rng-contracts/contracts/RNGInterface.sol";
import "../token/TokenListener.sol";
import "@pooltogether/fixed-point/contracts/FixedPoint.sol";
import "../token/TokenControllerInterface.sol";
import "../token/ControlledToken.sol";
import "../token/TicketInterface.sol";
import "../prize-pool/PrizePool.sol";
import "../Constants.sol";
import "./PeriodicPrizeStrategyListenerInterface.sol";
import "./PeriodicPrizeStrategyListenerLibrary.sol";
/* solium-disable security/no-block-members */
abstract contract PeriodicPrizeStrategy is Initializable,
OwnableUpgradeable,
TokenListener {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
using MappedSinglyLinkedList for MappedSinglyLinkedList.Mapping;
using AddressUpgradeable for address;
using ERC165CheckerUpgradeable for address;
uint256 internal constant ETHEREUM_BLOCK_TIME_ESTIMATE_MANTISSA = 13.4 ether;
event PrizePoolOpened(
address indexed operator,
uint256 indexed prizePeriodStartedAt
);
event RngRequestFailed();
event PrizePoolAwardStarted(
address indexed operator,
address indexed prizePool,
uint32 indexed rngRequestId,
uint32 rngLockBlock
);
event PrizePoolAwardCancelled(
address indexed operator,
address indexed prizePool,
uint32 indexed rngRequestId,
uint32 rngLockBlock
);
event PrizePoolAwarded(
address indexed operator,
uint256 randomNumber
);
event RngServiceUpdated(
RNGInterface indexed rngService
);
event TokenListenerUpdated(
TokenListenerInterface indexed tokenListener
);
event RngRequestTimeoutSet(
uint32 rngRequestTimeout
);
event PeriodicPrizeStrategyListenerSet(
PeriodicPrizeStrategyListenerInterface indexed periodicPrizeStrategyListener
);
event ExternalErc721AwardAdded(
IERC721Upgradeable indexed externalErc721,
uint256[] tokenIds
);
event ExternalErc20AwardAdded(
IERC20Upgradeable indexed externalErc20
);
event ExternalErc721AwardRemoved(
IERC721Upgradeable indexed externalErc721Award
);
event ExternalErc20AwardRemoved(
IERC20Upgradeable indexed externalErc20Award
);
event Initialized(
uint256 prizePeriodStart,
uint256 prizePeriodSeconds,
PrizePool indexed prizePool,
TicketInterface ticket,
IERC20Upgradeable sponsorship,
RNGInterface rng,
IERC20Upgradeable[] externalErc20Awards
);
struct RngRequest {
uint32 id;
uint32 lockBlock;
uint32 requestedAt;
}
// Comptroller
TokenListenerInterface public tokenListener;
// Contract Interfaces
PrizePool public prizePool;
TicketInterface public ticket;
IERC20Upgradeable public sponsorship;
RNGInterface public rng;
// Current RNG Request
RngRequest internal rngRequest;
/// @notice RNG Request Timeout. In fact, this is really a "complete award" timeout.
/// If the rng completes the award can still be cancelled.
uint32 public rngRequestTimeout;
// Prize period
uint256 public prizePeriodSeconds;
uint256 public prizePeriodStartedAt;
// External tokens awarded as part of prize
MappedSinglyLinkedList.Mapping internal externalErc20s;
MappedSinglyLinkedList.Mapping internal externalErc721s;
// External NFT token IDs to be awarded
// NFT Address => TokenIds
mapping (IERC721Upgradeable => uint256[]) internal externalErc721TokenIds;
/// @notice A listener that receives callbacks before certain events
PeriodicPrizeStrategyListenerInterface public periodicPrizeStrategyListener;
/// @notice Initializes a new strategy
/// @param _prizePeriodStart The starting timestamp of the prize period.
/// @param _prizePeriodSeconds The duration of the prize period in seconds
/// @param _prizePool The prize pool to award
/// @param _ticket The ticket to use to draw winners
/// @param _sponsorship The sponsorship token
/// @param _rng The RNG service to use
function initialize (
uint256 _prizePeriodStart,
uint256 _prizePeriodSeconds,
PrizePool _prizePool,
TicketInterface _ticket,
IERC20Upgradeable _sponsorship,
RNGInterface _rng,
IERC20Upgradeable[] memory externalErc20Awards
) public initializer {
require(_prizePeriodSeconds > 0, "PeriodicPrizeStrategy/prize-period-greater-than-zero");
require(address(_prizePool) != address(0), "PeriodicPrizeStrategy/prize-pool-not-zero");
require(address(_ticket) != address(0), "PeriodicPrizeStrategy/ticket-not-zero");
require(address(_sponsorship) != address(0), "PeriodicPrizeStrategy/sponsorship-not-zero");
require(address(_rng) != address(0), "PeriodicPrizeStrategy/rng-not-zero");
prizePool = _prizePool;
ticket = _ticket;
rng = _rng;
sponsorship = _sponsorship;
__Ownable_init();
Constants.REGISTRY.setInterfaceImplementer(address(this), Constants.TOKENS_RECIPIENT_INTERFACE_HASH, address(this));
externalErc20s.initialize();
for (uint256 i = 0; i < externalErc20Awards.length; i++) {
_addExternalErc20Award(externalErc20Awards[i]);
}
prizePeriodSeconds = _prizePeriodSeconds;
prizePeriodStartedAt = _prizePeriodStart;
externalErc721s.initialize();
// 30 min timeout
_setRngRequestTimeout(1800);
emit Initialized(
_prizePeriodStart,
_prizePeriodSeconds,
_prizePool,
_ticket,
_sponsorship,
_rng,
externalErc20Awards
);
emit PrizePoolOpened(_msgSender(), prizePeriodStartedAt);
}
function _distribute(uint256 randomNumber) internal virtual;
/// @notice Calculates and returns the currently accrued prize
/// @return The current prize size
function currentPrize() public view returns (uint256) {
return prizePool.awardBalance();
}
/// @notice Allows the owner to set the token listener
/// @param _tokenListener A contract that implements the token listener interface.
function setTokenListener(TokenListenerInterface _tokenListener) external onlyOwner requireAwardNotInProgress {
require(address(0) == address(_tokenListener) || address(_tokenListener).supportsInterface(TokenListenerLibrary.ERC165_INTERFACE_ID_TOKEN_LISTENER), "PeriodicPrizeStrategy/token-listener-invalid");
tokenListener = _tokenListener;
emit TokenListenerUpdated(tokenListener);
}
/// @notice Estimates the remaining blocks until the prize given a number of seconds per block
/// @param secondsPerBlockMantissa The number of seconds per block to use for the calculation. Should be a fixed point 18 number like Ether.
/// @return The estimated number of blocks remaining until the prize can be awarded.
function estimateRemainingBlocksToPrize(uint256 secondsPerBlockMantissa) public view returns (uint256) {
return FixedPoint.divideUintByMantissa(
_prizePeriodRemainingSeconds(),
secondsPerBlockMantissa
);
}
/// @notice Returns the number of seconds remaining until the prize can be awarded.
/// @return The number of seconds remaining until the prize can be awarded.
function prizePeriodRemainingSeconds() external view returns (uint256) {
return _prizePeriodRemainingSeconds();
}
/// @notice Returns the number of seconds remaining until the prize can be awarded.
/// @return The number of seconds remaining until the prize can be awarded.
function _prizePeriodRemainingSeconds() internal view returns (uint256) {
uint256 endAt = _prizePeriodEndAt();
uint256 time = _currentTime();
if (time > endAt) {
return 0;
}
return endAt.sub(time);
}
/// @notice Returns whether the prize period is over
/// @return True if the prize period is over, false otherwise
function isPrizePeriodOver() external view returns (bool) {
return _isPrizePeriodOver();
}
/// @notice Returns whether the prize period is over
/// @return True if the prize period is over, false otherwise
function _isPrizePeriodOver() internal view returns (bool) {
return _currentTime() >= _prizePeriodEndAt();
}
/// @notice Awards collateral as tickets to a user
/// @param user The user to whom the tickets are minted
/// @param amount The amount of interest to mint as tickets.
function _awardTickets(address user, uint256 amount) internal {
prizePool.award(user, amount, address(ticket));
}
/// @notice Awards all external tokens with non-zero balances to the given user. The external tokens must be held by the PrizePool contract.
/// @param winner The user to transfer the tokens to
function _awardAllExternalTokens(address winner) internal {
_awardExternalErc20s(winner);
_awardExternalErc721s(winner);
}
/// @notice Awards all external ERC20 tokens with non-zero balances to the given user.
/// The external tokens must be held by the PrizePool contract.
/// @param winner The user to transfer the tokens to
function _awardExternalErc20s(address winner) internal {
address currentToken = externalErc20s.start();
while (currentToken != address(0) && currentToken != externalErc20s.end()) {
uint256 balance = IERC20Upgradeable(currentToken).balanceOf(address(prizePool));
if (balance > 0) {
prizePool.awardExternalERC20(winner, currentToken, balance);
}
currentToken = externalErc20s.next(currentToken);
}
}
/// @notice Awards all external ERC721 tokens to the given user.
/// The external tokens must be held by the PrizePool contract.
/// @dev The list of ERC721s is reset after every award
/// @param winner The user to transfer the tokens to
function _awardExternalErc721s(address winner) internal {
address currentToken = externalErc721s.start();
while (currentToken != address(0) && currentToken != externalErc721s.end()) {
uint256 balance = IERC721Upgradeable(currentToken).balanceOf(address(prizePool));
if (balance > 0) {
prizePool.awardExternalERC721(winner, currentToken, externalErc721TokenIds[IERC721Upgradeable(currentToken)]);
_removeExternalErc721AwardTokens(IERC721Upgradeable(currentToken));
}
currentToken = externalErc721s.next(currentToken);
}
externalErc721s.clearAll();
}
/// @notice Returns the timestamp at which the prize period ends
/// @return The timestamp at which the prize period ends.
function prizePeriodEndAt() external view returns (uint256) {
// current prize started at is non-inclusive, so add one
return _prizePeriodEndAt();
}
/// @notice Returns the timestamp at which the prize period ends
/// @return The timestamp at which the prize period ends.
function _prizePeriodEndAt() internal view returns (uint256) {
// current prize started at is non-inclusive, so add one
return prizePeriodStartedAt.add(prizePeriodSeconds);
}
/// @notice Called by the PrizePool for transfers of controlled tokens
/// @dev Note that this is only for *transfers*, not mints or burns
/// @param controlledToken The type of collateral that is being sent
function beforeTokenTransfer(address from, address to, uint256 amount, address controlledToken) external override onlyPrizePool {
require(from != to, "PeriodicPrizeStrategy/transfer-to-self");
if (controlledToken == address(ticket)) {
_requireAwardNotInProgress();
}
if (address(tokenListener) != address(0)) {
tokenListener.beforeTokenTransfer(from, to, amount, controlledToken);
}
}
/// @notice Called by the PrizePool when minting controlled tokens
/// @param controlledToken The type of collateral that is being minted
function beforeTokenMint(
address to,
uint256 amount,
address controlledToken,
address referrer
)
external
override
onlyPrizePool
{
if (controlledToken == address(ticket)) {
_requireAwardNotInProgress();
}
if (address(tokenListener) != address(0)) {
tokenListener.beforeTokenMint(to, amount, controlledToken, referrer);
}
}
/// @notice returns the current time. Used for testing.
/// @return The current time (block.timestamp)
function _currentTime() internal virtual view returns (uint256) {
return block.timestamp;
}
/// @notice returns the current time. Used for testing.
/// @return The current time (block.timestamp)
function _currentBlock() internal virtual view returns (uint256) {
return block.number;
}
/// @notice Starts the award process by starting random number request. The prize period must have ended.
/// @dev The RNG-Request-Fee is expected to be held within this contract before calling this function
function startAward() external requireCanStartAward {
(address feeToken, uint256 requestFee) = rng.getRequestFee();
if (feeToken != address(0) && requestFee > 0) {
IERC20Upgradeable(feeToken).approve(address(rng), requestFee);
}
(uint32 requestId, uint32 lockBlock) = rng.requestRandomNumber();
rngRequest.id = requestId;
rngRequest.lockBlock = lockBlock;
rngRequest.requestedAt = _currentTime().toUint32();
emit PrizePoolAwardStarted(_msgSender(), address(prizePool), requestId, lockBlock);
}
/// @notice Can be called by anyone to unlock the tickets if the RNG has timed out.
function cancelAward() public {
require(isRngTimedOut(), "PeriodicPrizeStrategy/rng-not-timedout");
uint32 requestId = rngRequest.id;
uint32 lockBlock = rngRequest.lockBlock;
delete rngRequest;
emit RngRequestFailed();
emit PrizePoolAwardCancelled(msg.sender, address(prizePool), requestId, lockBlock);
}
/// @notice Completes the award process and awards the winners. The random number must have been requested and is now available.
function completeAward() external requireCanCompleteAward {
uint256 randomNumber = rng.randomNumber(rngRequest.id);
delete rngRequest;
_distribute(randomNumber);
if (address(periodicPrizeStrategyListener) != address(0)) {
periodicPrizeStrategyListener.afterPrizePoolAwarded(randomNumber, prizePeriodStartedAt);
}
// to avoid clock drift, we should calculate the start time based on the previous period start time.
prizePeriodStartedAt = _calculateNextPrizePeriodStartTime(_currentTime());
emit PrizePoolAwarded(_msgSender(), randomNumber);
emit PrizePoolOpened(_msgSender(), prizePeriodStartedAt);
}
/// @notice Allows the owner to set a listener for prize strategy callbacks.
/// @param _periodicPrizeStrategyListener The address of the listener contract
function setPeriodicPrizeStrategyListener(PeriodicPrizeStrategyListenerInterface _periodicPrizeStrategyListener) external onlyOwner requireAwardNotInProgress {
require(
address(0) == address(_periodicPrizeStrategyListener) || address(_periodicPrizeStrategyListener).supportsInterface(PeriodicPrizeStrategyListenerLibrary.ERC165_INTERFACE_ID_PERIODIC_PRIZE_STRATEGY_LISTENER),
"PeriodicPrizeStrategy/prizeStrategyListener-invalid"
);
periodicPrizeStrategyListener = _periodicPrizeStrategyListener;
emit PeriodicPrizeStrategyListenerSet(_periodicPrizeStrategyListener);
}
function _calculateNextPrizePeriodStartTime(uint256 currentTime) internal view returns (uint256) {
uint256 elapsedPeriods = currentTime.sub(prizePeriodStartedAt).div(prizePeriodSeconds);
return prizePeriodStartedAt.add(elapsedPeriods.mul(prizePeriodSeconds));
}
/// @notice Calculates when the next prize period will start
/// @param currentTime The timestamp to use as the current time
/// @return The timestamp at which the next prize period would start
function calculateNextPrizePeriodStartTime(uint256 currentTime) external view returns (uint256) {
return _calculateNextPrizePeriodStartTime(currentTime);
}
/// @notice Returns whether an award process can be started
/// @return True if an award can be started, false otherwise.
function canStartAward() external view returns (bool) {
return _isPrizePeriodOver() && !isRngRequested();
}
/// @notice Returns whether an award process can be completed
/// @return True if an award can be completed, false otherwise.
function canCompleteAward() external view returns (bool) {
return isRngRequested() && isRngCompleted();
}
/// @notice Returns whether a random number has been requested
/// @return True if a random number has been requested, false otherwise.
function isRngRequested() public view returns (bool) {
return rngRequest.id != 0;
}
/// @notice Returns whether the random number request has completed.
/// @return True if a random number request has completed, false otherwise.
function isRngCompleted() public view returns (bool) {
return rng.isRequestComplete(rngRequest.id);
}
/// @notice Returns the block number that the current RNG request has been locked to
/// @return The block number that the RNG request is locked to
function getLastRngLockBlock() external view returns (uint32) {
return rngRequest.lockBlock;
}
/// @notice Returns the current RNG Request ID
/// @return The current Request ID
function getLastRngRequestId() external view returns (uint32) {
return rngRequest.id;
}
/// @notice Sets the RNG service that the Prize Strategy is connected to
/// @param rngService The address of the new RNG service interface
function setRngService(RNGInterface rngService) external onlyOwner requireAwardNotInProgress {
require(!isRngRequested(), "PeriodicPrizeStrategy/rng-in-flight");
rng = rngService;
emit RngServiceUpdated(rngService);
}
function setRngRequestTimeout(uint32 _rngRequestTimeout) external onlyOwner requireAwardNotInProgress {
_setRngRequestTimeout(_rngRequestTimeout);
}
function _setRngRequestTimeout(uint32 _rngRequestTimeout) internal {
require(_rngRequestTimeout > 60, "PeriodicPrizeStrategy/rng-timeout-gt-60-secs");
rngRequestTimeout = _rngRequestTimeout;
emit RngRequestTimeoutSet(rngRequestTimeout);
}
/// @notice Gets the current list of External ERC20 tokens that will be awarded with the current prize
/// @return An array of External ERC20 token addresses
function getExternalErc20Awards() external view returns (address[] memory) {
return externalErc20s.addressArray();
}
/// @notice Adds an external ERC20 token type as an additional prize that can be awarded
/// @dev Only the Prize-Strategy owner/creator can assign external tokens,
/// and they must be approved by the Prize-Pool
/// @param _externalErc20 The address of an ERC20 token to be awarded
function addExternalErc20Award(IERC20Upgradeable _externalErc20) external onlyOwnerOrListener requireAwardNotInProgress {
_addExternalErc20Award(_externalErc20);
}
function _addExternalErc20Award(IERC20Upgradeable _externalErc20) internal {
require(address(_externalErc20).isContract(), "PeriodicPrizeStrategy/erc20-null");
require(prizePool.canAwardExternal(address(_externalErc20)), "PeriodicPrizeStrategy/cannot-award-external");
(bool succeeded, bytes memory returnValue) = address(_externalErc20).staticcall(abi.encodeWithSignature("totalSupply()"));
require(succeeded, "PeriodicPrizeStrategy/erc20-invalid");
externalErc20s.addAddress(address(_externalErc20));
emit ExternalErc20AwardAdded(_externalErc20);
}
function addExternalErc20Awards(IERC20Upgradeable[] calldata _externalErc20s) external onlyOwnerOrListener requireAwardNotInProgress {
for (uint256 i = 0; i < _externalErc20s.length; i++) {
_addExternalErc20Award(_externalErc20s[i]);
}
}
/// @notice Removes an external ERC20 token type as an additional prize that can be awarded
/// @dev Only the Prize-Strategy owner/creator can remove external tokens
/// @param _externalErc20 The address of an ERC20 token to be removed
/// @param _prevExternalErc20 The address of the previous ERC20 token in the `externalErc20s` list.
/// If the ERC20 is the first address, then the previous address is the SENTINEL address: 0x0000000000000000000000000000000000000001
function removeExternalErc20Award(IERC20Upgradeable _externalErc20, IERC20Upgradeable _prevExternalErc20) external onlyOwner requireAwardNotInProgress {
externalErc20s.removeAddress(address(_prevExternalErc20), address(_externalErc20));
emit ExternalErc20AwardRemoved(_externalErc20);
}
/// @notice Gets the current list of External ERC721 tokens that will be awarded with the current prize
/// @return An array of External ERC721 token addresses
function getExternalErc721Awards() external view returns (address[] memory) {
return externalErc721s.addressArray();
}
/// @notice Gets the current list of External ERC721 tokens that will be awarded with the current prize
/// @return An array of External ERC721 token addresses
function getExternalErc721AwardTokenIds(IERC721Upgradeable _externalErc721) external view returns (uint256[] memory) {
return externalErc721TokenIds[_externalErc721];
}
/// @notice Adds an external ERC721 token as an additional prize that can be awarded
/// @dev Only the Prize-Strategy owner/creator can assign external tokens,
/// and they must be approved by the Prize-Pool
/// NOTE: The NFT must already be owned by the Prize-Pool
/// @param _externalErc721 The address of an ERC721 token to be awarded
/// @param _tokenIds An array of token IDs of the ERC721 to be awarded
function addExternalErc721Award(IERC721Upgradeable _externalErc721, uint256[] calldata _tokenIds) external onlyOwnerOrListener requireAwardNotInProgress {
require(prizePool.canAwardExternal(address(_externalErc721)), "PeriodicPrizeStrategy/cannot-award-external");
require(address(_externalErc721).supportsInterface(Constants.ERC165_INTERFACE_ID_ERC721), "PeriodicPrizeStrategy/erc721-invalid");
if (!externalErc721s.contains(address(_externalErc721))) {
externalErc721s.addAddress(address(_externalErc721));
}
for (uint256 i = 0; i < _tokenIds.length; i++) {
_addExternalErc721Award(_externalErc721, _tokenIds[i]);
}
emit ExternalErc721AwardAdded(_externalErc721, _tokenIds);
}
function _addExternalErc721Award(IERC721Upgradeable _externalErc721, uint256 _tokenId) internal {
require(IERC721Upgradeable(_externalErc721).ownerOf(_tokenId) == address(prizePool), "PeriodicPrizeStrategy/unavailable-token");
for (uint256 i = 0; i < externalErc721TokenIds[_externalErc721].length; i++) {
if (externalErc721TokenIds[_externalErc721][i] == _tokenId) {
revert("PeriodicPrizeStrategy/erc721-duplicate");
}
}
externalErc721TokenIds[_externalErc721].push(_tokenId);
}
/// @notice Removes an external ERC721 token as an additional prize that can be awarded
/// @dev Only the Prize-Strategy owner/creator can remove external tokens
/// @param _externalErc721 The address of an ERC721 token to be removed
/// @param _prevExternalErc721 The address of the previous ERC721 token in the list.
/// If no previous, then pass the SENTINEL address: 0x0000000000000000000000000000000000000001
function removeExternalErc721Award(
IERC721Upgradeable _externalErc721,
IERC721Upgradeable _prevExternalErc721
)
external
onlyOwner
requireAwardNotInProgress
{
externalErc721s.removeAddress(address(_prevExternalErc721), address(_externalErc721));
_removeExternalErc721AwardTokens(_externalErc721);
}
function _removeExternalErc721AwardTokens(
IERC721Upgradeable _externalErc721
)
internal
{
delete externalErc721TokenIds[_externalErc721];
emit ExternalErc721AwardRemoved(_externalErc721);
}
/// @notice Allows the owner to transfer out external ERC20 tokens
/// @dev Used to transfer out tokens held by the Prize Pool. Could be liquidated, or anything.
/// @param to The address that receives the tokens
/// @param externalToken The address of the external asset token being transferred
/// @param amount The amount of external assets to be transferred
function transferExternalERC20(
address to,
address externalToken,
uint256 amount
)
external
onlyOwner
requireAwardNotInProgress
{
prizePool.transferExternalERC20(to, externalToken, amount);
}
function _requireAwardNotInProgress() internal view {
uint256 currentBlock = _currentBlock();
require(rngRequest.lockBlock == 0 || currentBlock < rngRequest.lockBlock, "PeriodicPrizeStrategy/rng-in-flight");
}
function isRngTimedOut() public view returns (bool) {
if (rngRequest.requestedAt == 0) {
return false;
} else {
return _currentTime() > uint256(rngRequestTimeout).add(rngRequest.requestedAt);
}
}
modifier onlyOwnerOrListener() {
require(_msgSender() == owner() || _msgSender() == address(periodicPrizeStrategyListener), "PeriodicPrizeStrategy/only-owner-or-listener");
_;
}
modifier requireAwardNotInProgress() {
_requireAwardNotInProgress();
_;
}
modifier requireCanStartAward() {
require(_isPrizePeriodOver(), "PeriodicPrizeStrategy/prize-period-not-over");
require(!isRngRequested(), "PeriodicPrizeStrategy/rng-already-requested");
_;
}
modifier requireCanCompleteAward() {
require(isRngRequested(), "PeriodicPrizeStrategy/rng-not-requested");
require(isRngCompleted(), "PeriodicPrizeStrategy/rng-not-complete");
_;
}
modifier onlyPrizePool() {
require(_msgSender() == address(prizePool), "PeriodicPrizeStrategy/only-prize-pool");
_;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0;
/// @title Random Number Generator Interface
/// @notice Provides an interface for requesting random numbers from 3rd-party RNG services (Chainlink VRF, Starkware VDF, etc..)
interface RNGInterface {
/// @notice Emitted when a new request for a random number has been submitted
/// @param requestId The indexed ID of the request used to get the results of the RNG service
/// @param sender The indexed address of the sender of the request
event RandomNumberRequested(uint32 indexed requestId, address indexed sender);
/// @notice Emitted when an existing request for a random number has been completed
/// @param requestId The indexed ID of the request used to get the results of the RNG service
/// @param randomNumber The random number produced by the 3rd-party service
event RandomNumberCompleted(uint32 indexed requestId, uint256 randomNumber);
/// @notice Gets the last request id used by the RNG service
/// @return requestId The last request id used in the last request
function getLastRequestId() external view returns (uint32 requestId);
/// @notice Gets the Fee for making a Request against an RNG service
/// @return feeToken The address of the token that is used to pay fees
/// @return requestFee The fee required to be paid to make a request
function getRequestFee() external view returns (address feeToken, uint256 requestFee);
/// @notice Sends a request for a random number to the 3rd-party service
/// @dev Some services will complete the request immediately, others may have a time-delay
/// @dev Some services require payment in the form of a token, such as $LINK for Chainlink VRF
/// @return requestId The ID of the request used to get the results of the RNG service
/// @return lockBlock The block number at which the RNG service will start generating time-delayed randomness. The calling contract
/// should "lock" all activity until the result is available via the `requestId`
function requestRandomNumber() external returns (uint32 requestId, uint32 lockBlock);
/// @notice Checks if the request for randomness from the 3rd-party service has completed
/// @dev For time-delayed requests, this function is used to check/confirm completion
/// @param requestId The ID of the request used to get the results of the RNG service
/// @return isCompleted True if the request has completed and a random number is available, false otherwise
function isRequestComplete(uint32 requestId) external view returns (bool isCompleted);
/// @notice Gets the random number produced by the 3rd-party service
/// @param requestId The ID of the request used to get the results of the RNG service
/// @return randomNum The random number
function randomNumber(uint32 requestId) external returns (uint256 randomNum);
}
pragma solidity ^0.6.4;
import "./TokenListenerInterface.sol";
import "./TokenListenerLibrary.sol";
import "../Constants.sol";
abstract contract TokenListener is TokenListenerInterface {
function supportsInterface(bytes4 interfaceId) external override view returns (bool) {
return (
interfaceId == Constants.ERC165_INTERFACE_ID_ERC165 ||
interfaceId == TokenListenerLibrary.ERC165_INTERFACE_ID_TOKEN_LISTENER
);
}
}
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/introspection/IERC1820RegistryUpgradeable.sol";
library Constants {
IERC1820RegistryUpgradeable public constant REGISTRY = IERC1820RegistryUpgradeable(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
// keccak256("ERC777TokensSender")
bytes32 public constant TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 public constant TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// keccak256(abi.encodePacked("ERC1820_ACCEPT_MAGIC"));
bytes32 public constant ACCEPT_MAGIC =
0xa2ef4600d742022d532d4747cb3547474667d6f13804902513b2ec01c848f4b4;
bytes4 public constant ERC165_INTERFACE_ID_ERC165 = 0x01ffc9a7;
bytes4 public constant ERC165_INTERFACE_ID_ERC721 = 0x80ac58cd;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the global ERC1820 Registry, as defined in the
* https://eips.ethereum.org/EIPS/eip-1820[EIP]. Accounts may register
* implementers for interfaces in this registry, as well as query support.
*
* Implementers may be shared by multiple accounts, and can also implement more
* than a single interface for each account. Contracts can implement interfaces
* for themselves, but externally-owned accounts (EOA) must delegate this to a
* contract.
*
* {IERC165} interfaces can also be queried via the registry.
*
* For an in-depth explanation and source code analysis, see the EIP text.
*/
interface IERC1820RegistryUpgradeable {
/**
* @dev Sets `newManager` as the manager for `account`. A manager of an
* account is able to set interface implementers for it.
*
* By default, each account is its own manager. Passing a value of `0x0` in
* `newManager` will reset the manager to this initial state.
*
* Emits a {ManagerChanged} event.
*
* Requirements:
*
* - the caller must be the current manager for `account`.
*/
function setManager(address account, address newManager) external;
/**
* @dev Returns the manager for `account`.
*
* See {setManager}.
*/
function getManager(address account) external view returns (address);
/**
* @dev Sets the `implementer` contract as ``account``'s implementer for
* `interfaceHash`.
*
* `account` being the zero address is an alias for the caller's address.
* The zero address can also be used in `implementer` to remove an old one.
*
* See {interfaceHash} to learn how these are created.
*
* Emits an {InterfaceImplementerSet} event.
*
* Requirements:
*
* - the caller must be the current manager for `account`.
* - `interfaceHash` must not be an {IERC165} interface id (i.e. it must not
* end in 28 zeroes).
* - `implementer` must implement {IERC1820Implementer} and return true when
* queried for support, unless `implementer` is the caller. See
* {IERC1820Implementer-canImplementInterfaceForAddress}.
*/
function setInterfaceImplementer(address account, bytes32 _interfaceHash, address implementer) external;
/**
* @dev Returns the implementer of `interfaceHash` for `account`. If no such
* implementer is registered, returns the zero address.
*
* If `interfaceHash` is an {IERC165} interface id (i.e. it ends with 28
* zeroes), `account` will be queried for support of it.
*
* `account` being the zero address is an alias for the caller's address.
*/
function getInterfaceImplementer(address account, bytes32 _interfaceHash) external view returns (address);
/**
* @dev Returns the interface hash for an `interfaceName`, as defined in the
* corresponding
* https://eips.ethereum.org/EIPS/eip-1820#interface-name[section of the EIP].
*/
function interfaceHash(string calldata interfaceName) external pure returns (bytes32);
/**
* @notice Updates the cache with whether the contract implements an ERC165 interface or not.
* @param account Address of the contract for which to update the cache.
* @param interfaceId ERC165 interface for which to update the cache.
*/
function updateERC165Cache(address account, bytes4 interfaceId) external;
/**
* @notice Checks whether a contract implements an ERC165 interface or not.
* If the result is not cached a direct lookup on the contract address is performed.
* If the result is not cached or the cached value is out-of-date, the cache MUST be updated manually by calling
* {updateERC165Cache} with the contract address.
* @param account Address of the contract to check.
* @param interfaceId ERC165 interface to check.
* @return True if `account` implements `interfaceId`, false otherwise.
*/
function implementsERC165Interface(address account, bytes4 interfaceId) external view returns (bool);
/**
* @notice Checks whether a contract implements an ERC165 interface or not without using nor updating the cache.
* @param account Address of the contract to check.
* @param interfaceId ERC165 interface to check.
* @return True if `account` implements `interfaceId`, false otherwise.
*/
function implementsERC165InterfaceNoCache(address account, bytes4 interfaceId) external view returns (bool);
event InterfaceImplementerSet(address indexed account, bytes32 indexed interfaceHash, address indexed implementer);
event ManagerChanged(address indexed account, address indexed newManager);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;
/// @title Interface that allows a user to draw an address using an index
interface TicketInterface {
/// @notice Selects a user using a random number. The random number will be uniformly bounded to the ticket totalSupply.
/// @param randomNumber The random number to use to select a user.
/// @return The winner
function draw(uint256 randomNumber) external view returns (address);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/introspection/IERC165Upgradeable.sol";
/* solium-disable security/no-block-members */
interface PeriodicPrizeStrategyListenerInterface is IERC165Upgradeable {
function afterPrizePoolAwarded(uint256 randomNumber, uint256 prizePeriodStartedAt) external;
}
pragma solidity ^0.6.12;
library PeriodicPrizeStrategyListenerLibrary {
/*
* bytes4(keccak256('afterPrizePoolAwarded(uint256,uint256)')) == 0x575072c6
*/
bytes4 public constant ERC165_INTERFACE_ID_PERIODIC_PRIZE_STRATEGY_LISTENER = 0x575072c6;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "./CompoundPrizePool.sol";
import "../../external/openzeppelin/ProxyFactory.sol";
/// @title Compound Prize Pool Proxy Factory
/// @notice Minimal proxy pattern for creating new Compound Prize Pools
contract CompoundPrizePoolProxyFactory is ProxyFactory {
/// @notice Contract template for deploying proxied Prize Pools
CompoundPrizePool public instance;
/// @notice Initializes the Factory with an instance of the Compound Prize Pool
constructor () public {
instance = new CompoundPrizePool();
}
/// @notice Creates a new Compound Prize Pool as a proxy of the template instance
/// @return A reference to the new proxied Compound Prize Pool
function create() external returns (CompoundPrizePool) {
return CompoundPrizePool(deployMinimal(address(instance), ""));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@pooltogether/fixed-point/contracts/FixedPoint.sol";
import "../../external/compound/CTokenInterface.sol";
import "../PrizePool.sol";
/// @title Prize Pool with Compound's cToken
/// @notice Manages depositing and withdrawing assets from the Prize Pool
contract CompoundPrizePool is PrizePool {
using SafeMathUpgradeable for uint256;
event CompoundPrizePoolInitialized(address indexed cToken);
/// @notice Interface for the Yield-bearing cToken by Compound
CTokenInterface public cToken;
/// @notice Initializes the Prize Pool and Yield Service with the required contract connections
/// @param _controlledTokens Array of addresses for the Ticket and Sponsorship Tokens controlled by the Prize Pool
/// @param _maxExitFeeMantissa The maximum exit fee size, relative to the withdrawal amount
/// @param _maxTimelockDuration The maximum length of time the withdraw timelock could be
/// @param _cToken Address of the Compound cToken interface
function initialize (
RegistryInterface _reserveRegistry,
ControlledTokenInterface[] memory _controlledTokens,
uint256 _maxExitFeeMantissa,
uint256 _maxTimelockDuration,
CTokenInterface _cToken
)
public
initializer
{
PrizePool.initialize(
_reserveRegistry,
_controlledTokens,
_maxExitFeeMantissa,
_maxTimelockDuration
);
cToken = _cToken;
emit CompoundPrizePoolInitialized(address(cToken));
}
/// @dev Gets the balance of the underlying assets held by the Yield Service
/// @return The underlying balance of asset tokens
function _balance() internal override returns (uint256) {
return cToken.balanceOfUnderlying(address(this));
}
/// @dev Allows a user to supply asset tokens in exchange for yield-bearing tokens
/// to be held in escrow by the Yield Service
/// @param amount The amount of asset tokens to be supplied
function _supply(uint256 amount) internal override {
_token().approve(address(cToken), amount);
require(cToken.mint(amount) == 0, "CompoundPrizePool/mint-failed");
}
/// @dev Checks with the Prize Pool if a specific token type may be awarded as a prize enhancement
/// @param _externalToken The address of the token to check
/// @return True if the token may be awarded, false otherwise
function _canAwardExternal(address _externalToken) internal override view returns (bool) {
return _externalToken != address(cToken);
}
/// @dev Allows a user to redeem yield-bearing tokens in exchange for the underlying
/// asset tokens held in escrow by the Yield Service
/// @param amount The amount of underlying tokens to be redeemed
/// @return The actual amount of tokens transferred
function _redeem(uint256 amount) internal override returns (uint256) {
IERC20Upgradeable assetToken = _token();
uint256 before = assetToken.balanceOf(address(this));
require(cToken.redeemUnderlying(amount) == 0, "CompoundPrizePool/redeem-failed");
uint256 diff = assetToken.balanceOf(address(this)).sub(before);
return diff;
}
/// @dev Gets the underlying asset token used by the Yield Service
/// @return A reference to the interface of the underling asset token
function _token() internal override view returns (IERC20Upgradeable) {
return IERC20Upgradeable(cToken.underlying());
}
}
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
interface CTokenInterface is IERC20Upgradeable {
function decimals() external view returns (uint8);
function totalSupply() external override view returns (uint256);
function underlying() external view returns (address);
function balanceOfUnderlying(address owner) external returns (uint256);
function supplyRatePerBlock() external returns (uint256);
function exchangeRateCurrent() external returns (uint256);
function mint(uint256 mintAmount) external returns (uint256);
function balanceOf(address user) external override view returns (uint256);
function redeemUnderlying(uint256 redeemAmount) external returns (uint256);
}
pragma solidity >=0.6.0 <0.7.0;
// solium-disable security/no-inline-assembly
// solium-disable security/no-low-level-calls
contract ProxyFactory {
event ProxyCreated(address proxy);
function deployMinimal(address _logic, bytes memory _data) public returns (address proxy) {
// Adapted from https://github.com/optionality/clone-factory/blob/32782f82dfc5a00d103a7e61a17a5dedbd1e8e9d/contracts/CloneFactory.sol
bytes20 targetBytes = bytes20(_logic);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), targetBytes)
mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
proxy := create(0, clone, 0x37)
}
emit ProxyCreated(address(proxy));
if(_data.length > 0) {
(bool success,) = proxy.call(_data);
require(success, "ProxyFactory/constructor-call-failed");
}
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "../token/ControlledTokenProxyFactory.sol";
import "../token/TicketProxyFactory.sol";
/* solium-disable security/no-block-members */
contract ControlledTokenBuilder {
event CreatedControlledToken(address indexed token);
event CreatedTicket(address indexed token);
ControlledTokenProxyFactory public controlledTokenProxyFactory;
TicketProxyFactory public ticketProxyFactory;
struct ControlledTokenConfig {
string name;
string symbol;
uint8 decimals;
TokenControllerInterface controller;
}
constructor (
ControlledTokenProxyFactory _controlledTokenProxyFactory,
TicketProxyFactory _ticketProxyFactory
) public {
require(address(_controlledTokenProxyFactory) != address(0), "ControlledTokenBuilder/controlledTokenProxyFactory-not-zero");
require(address(_ticketProxyFactory) != address(0), "ControlledTokenBuilder/ticketProxyFactory-not-zero");
controlledTokenProxyFactory = _controlledTokenProxyFactory;
ticketProxyFactory = _ticketProxyFactory;
}
function createControlledToken(
ControlledTokenConfig calldata config
) external returns (ControlledToken) {
ControlledToken token = controlledTokenProxyFactory.create();
token.initialize(
config.name,
config.symbol,
config.decimals,
config.controller
);
emit CreatedControlledToken(address(token));
return token;
}
function createTicket(
ControlledTokenConfig calldata config
) external returns (Ticket) {
Ticket token = ticketProxyFactory.create();
token.initialize(
config.name,
config.symbol,
config.decimals,
config.controller
);
emit CreatedTicket(address(token));
return token;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "./ControlledToken.sol";
import "../external/openzeppelin/ProxyFactory.sol";
/// @title Controlled ERC20 Token Factory
/// @notice Minimal proxy pattern for creating new Controlled ERC20 Tokens
contract ControlledTokenProxyFactory is ProxyFactory {
/// @notice Contract template for deploying proxied tokens
ControlledToken public instance;
/// @notice Initializes the Factory with an instance of the Controlled ERC20 Token
constructor () public {
instance = new ControlledToken();
}
/// @notice Creates a new Controlled ERC20 Token as a proxy of the template instance
/// @return A reference to the new proxied Controlled ERC20 Token
function create() external returns (ControlledToken) {
return ControlledToken(deployMinimal(address(instance), ""));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
import "./Ticket.sol";
import "../external/openzeppelin/ProxyFactory.sol";
/// @title Controlled ERC20 Token Factory
/// @notice Minimal proxy pattern for creating new Controlled ERC20 Tokens
contract TicketProxyFactory is ProxyFactory {
/// @notice Contract template for deploying proxied tokens
Ticket public instance;
/// @notice Initializes the Factory with an instance of the Controlled ERC20 Token
constructor () public {
instance = new Ticket();
}
/// @notice Creates a new Controlled ERC20 Token as a proxy of the template instance
/// @return A reference to the new proxied Controlled ERC20 Token
function create() external returns (Ticket) {
return Ticket(deployMinimal(address(instance), ""));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "sortition-sum-tree-factory/contracts/SortitionSumTreeFactory.sol";
import "@pooltogether/uniform-random-number/contracts/UniformRandomNumber.sol";
import "./ControlledToken.sol";
import "./TicketInterface.sol";
contract Ticket is ControlledToken, TicketInterface {
using SortitionSumTreeFactory for SortitionSumTreeFactory.SortitionSumTrees;
bytes32 constant private TREE_KEY = keccak256("PoolTogether/Ticket");
uint256 constant private MAX_TREE_LEAVES = 5;
// Ticket-weighted odds
SortitionSumTreeFactory.SortitionSumTrees internal sortitionSumTrees;
/// @notice Initializes the Controlled Token with Token Details and the Controller
/// @param _name The name of the Token
/// @param _symbol The symbol for the Token
/// @param _decimals The number of decimals for the Token
/// @param _controller Address of the Controller contract for minting & burning
function initialize(
string memory _name,
string memory _symbol,
uint8 _decimals,
TokenControllerInterface _controller
)
public
virtual
override
initializer
{
super.initialize(_name, _symbol, _decimals, _controller);
sortitionSumTrees.createTree(TREE_KEY, MAX_TREE_LEAVES);
}
/// @notice Returns the user's chance of winning.
function chanceOf(address user) external view returns (uint256) {
return sortitionSumTrees.stakeOf(TREE_KEY, bytes32(uint256(user)));
}
/// @notice Selects a user using a random number. The random number will be uniformly bounded to the ticket totalSupply.
/// @param randomNumber The random number to use to select a user.
/// @return The winner
function draw(uint256 randomNumber) external view override returns (address) {
uint256 bound = totalSupply();
address selected;
if (bound == 0) {
selected = address(0);
} else {
uint256 token = UniformRandomNumber.uniform(randomNumber, bound);
selected = address(uint256(sortitionSumTrees.draw(TREE_KEY, token)));
}
return selected;
}
/// @dev Controller hook to provide notifications & rule validations on token transfers to the controller.
/// This includes minting and burning.
/// May be overridden to provide more granular control over operator-burning
/// @param from Address of the account sending the tokens (address(0x0) on minting)
/// @param to Address of the account receiving the tokens (address(0x0) on burning)
/// @param amount Amount of tokens being transferred
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
// optimize: ignore transfers to self
if (from == to) {
return;
}
if (from != address(0)) {
uint256 fromBalance = balanceOf(from).sub(amount);
sortitionSumTrees.set(TREE_KEY, fromBalance, bytes32(uint256(from)));
}
if (to != address(0)) {
uint256 toBalance = balanceOf(to).add(amount);
sortitionSumTrees.set(TREE_KEY, toBalance, bytes32(uint256(to)));
}
}
}
/**
* @reviewers: [@clesaege, @unknownunknown1, @ferittuncer]
* @auditors: []
* @bounties: [<14 days 10 ETH max payout>]
* @deployments: []
*/
pragma solidity ^0.6.0;
/**
* @title SortitionSumTreeFactory
* @author Enrique Piqueras - <[email protected]>
* @dev A factory of trees that keep track of staked values for sortition.
*/
library SortitionSumTreeFactory {
/* Structs */
struct SortitionSumTree {
uint K; // The maximum number of childs per node.
// We use this to keep track of vacant positions in the tree after removing a leaf. This is for keeping the tree as balanced as possible without spending gas on moving nodes around.
uint[] stack;
uint[] nodes;
// Two-way mapping of IDs to node indexes. Note that node index 0 is reserved for the root node, and means the ID does not have a node.
mapping(bytes32 => uint) IDsToNodeIndexes;
mapping(uint => bytes32) nodeIndexesToIDs;
}
/* Storage */
struct SortitionSumTrees {
mapping(bytes32 => SortitionSumTree) sortitionSumTrees;
}
/* internal */
/**
* @dev Create a sortition sum tree at the specified key.
* @param _key The key of the new tree.
* @param _K The number of children each node in the tree should have.
*/
function createTree(SortitionSumTrees storage self, bytes32 _key, uint _K) internal {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
require(tree.K == 0, "Tree already exists.");
require(_K > 1, "K must be greater than one.");
tree.K = _K;
tree.stack = new uint[](0);
tree.nodes = new uint[](0);
tree.nodes.push(0);
}
/**
* @dev Set a value of a tree.
* @param _key The key of the tree.
* @param _value The new value.
* @param _ID The ID of the value.
* `O(log_k(n))` where
* `k` is the maximum number of childs per node in the tree,
* and `n` is the maximum number of nodes ever appended.
*/
function set(SortitionSumTrees storage self, bytes32 _key, uint _value, bytes32 _ID) internal {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
uint treeIndex = tree.IDsToNodeIndexes[_ID];
if (treeIndex == 0) { // No existing node.
if (_value != 0) { // Non zero value.
// Append.
// Add node.
if (tree.stack.length == 0) { // No vacant spots.
// Get the index and append the value.
treeIndex = tree.nodes.length;
tree.nodes.push(_value);
// Potentially append a new node and make the parent a sum node.
if (treeIndex != 1 && (treeIndex - 1) % tree.K == 0) { // Is first child.
uint parentIndex = treeIndex / tree.K;
bytes32 parentID = tree.nodeIndexesToIDs[parentIndex];
uint newIndex = treeIndex + 1;
tree.nodes.push(tree.nodes[parentIndex]);
delete tree.nodeIndexesToIDs[parentIndex];
tree.IDsToNodeIndexes[parentID] = newIndex;
tree.nodeIndexesToIDs[newIndex] = parentID;
}
} else { // Some vacant spot.
// Pop the stack and append the value.
treeIndex = tree.stack[tree.stack.length - 1];
tree.stack.pop();
tree.nodes[treeIndex] = _value;
}
// Add label.
tree.IDsToNodeIndexes[_ID] = treeIndex;
tree.nodeIndexesToIDs[treeIndex] = _ID;
updateParents(self, _key, treeIndex, true, _value);
}
} else { // Existing node.
if (_value == 0) { // Zero value.
// Remove.
// Remember value and set to 0.
uint value = tree.nodes[treeIndex];
tree.nodes[treeIndex] = 0;
// Push to stack.
tree.stack.push(treeIndex);
// Clear label.
delete tree.IDsToNodeIndexes[_ID];
delete tree.nodeIndexesToIDs[treeIndex];
updateParents(self, _key, treeIndex, false, value);
} else if (_value != tree.nodes[treeIndex]) { // New, non zero value.
// Set.
bool plusOrMinus = tree.nodes[treeIndex] <= _value;
uint plusOrMinusValue = plusOrMinus ? _value - tree.nodes[treeIndex] : tree.nodes[treeIndex] - _value;
tree.nodes[treeIndex] = _value;
updateParents(self, _key, treeIndex, plusOrMinus, plusOrMinusValue);
}
}
}
/* internal Views */
/**
* @dev Query the leaves of a tree. Note that if `startIndex == 0`, the tree is empty and the root node will be returned.
* @param _key The key of the tree to get the leaves from.
* @param _cursor The pagination cursor.
* @param _count The number of items to return.
* @return startIndex The index at which leaves start
* @return values The values of the returned leaves
* @return hasMore Whether there are more for pagination.
* `O(n)` where
* `n` is the maximum number of nodes ever appended.
*/
function queryLeafs(
SortitionSumTrees storage self,
bytes32 _key,
uint _cursor,
uint _count
) internal view returns(uint startIndex, uint[] memory values, bool hasMore) {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
// Find the start index.
for (uint i = 0; i < tree.nodes.length; i++) {
if ((tree.K * i) + 1 >= tree.nodes.length) {
startIndex = i;
break;
}
}
// Get the values.
uint loopStartIndex = startIndex + _cursor;
values = new uint[](loopStartIndex + _count > tree.nodes.length ? tree.nodes.length - loopStartIndex : _count);
uint valuesIndex = 0;
for (uint j = loopStartIndex; j < tree.nodes.length; j++) {
if (valuesIndex < _count) {
values[valuesIndex] = tree.nodes[j];
valuesIndex++;
} else {
hasMore = true;
break;
}
}
}
/**
* @dev Draw an ID from a tree using a number. Note that this function reverts if the sum of all values in the tree is 0.
* @param _key The key of the tree.
* @param _drawnNumber The drawn number.
* @return ID The drawn ID.
* `O(k * log_k(n))` where
* `k` is the maximum number of childs per node in the tree,
* and `n` is the maximum number of nodes ever appended.
*/
function draw(SortitionSumTrees storage self, bytes32 _key, uint _drawnNumber) internal view returns(bytes32 ID) {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
uint treeIndex = 0;
uint currentDrawnNumber = _drawnNumber % tree.nodes[0];
while ((tree.K * treeIndex) + 1 < tree.nodes.length) // While it still has children.
for (uint i = 1; i <= tree.K; i++) { // Loop over children.
uint nodeIndex = (tree.K * treeIndex) + i;
uint nodeValue = tree.nodes[nodeIndex];
if (currentDrawnNumber >= nodeValue) currentDrawnNumber -= nodeValue; // Go to the next child.
else { // Pick this child.
treeIndex = nodeIndex;
break;
}
}
ID = tree.nodeIndexesToIDs[treeIndex];
}
/** @dev Gets a specified ID's associated value.
* @param _key The key of the tree.
* @param _ID The ID of the value.
* @return value The associated value.
*/
function stakeOf(SortitionSumTrees storage self, bytes32 _key, bytes32 _ID) internal view returns(uint value) {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
uint treeIndex = tree.IDsToNodeIndexes[_ID];
if (treeIndex == 0) value = 0;
else value = tree.nodes[treeIndex];
}
function total(SortitionSumTrees storage self, bytes32 _key) internal view returns (uint) {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
if (tree.nodes.length == 0) {
return 0;
} else {
return tree.nodes[0];
}
}
/* Private */
/**
* @dev Update all the parents of a node.
* @param _key The key of the tree to update.
* @param _treeIndex The index of the node to start from.
* @param _plusOrMinus Wether to add (true) or substract (false).
* @param _value The value to add or substract.
* `O(log_k(n))` where
* `k` is the maximum number of childs per node in the tree,
* and `n` is the maximum number of nodes ever appended.
*/
function updateParents(SortitionSumTrees storage self, bytes32 _key, uint _treeIndex, bool _plusOrMinus, uint _value) private {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
uint parentIndex = _treeIndex;
while (parentIndex != 0) {
parentIndex = (parentIndex - 1) / tree.K;
tree.nodes[parentIndex] = _plusOrMinus ? tree.nodes[parentIndex] + _value : tree.nodes[parentIndex] - _value;
}
}
}
/**
Copyright 2019 PoolTogether LLC
This file is part of PoolTogether.
PoolTogether is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation under version 3 of the License.
PoolTogether is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with PoolTogether. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.0 <0.8.0;
/**
* @author Brendan Asselstine
* @notice A library that uses entropy to select a random number within a bound. Compensates for modulo bias.
* @dev Thanks to https://medium.com/hownetworks/dont-waste-cycles-with-modulo-bias-35b6fdafcf94
*/
library UniformRandomNumber {
/// @notice Select a random number without modulo bias using a random seed and upper bound
/// @param _entropy The seed for randomness
/// @param _upperBound The upper bound of the desired number
/// @return A random number less than the _upperBound
function uniform(uint256 _entropy, uint256 _upperBound) internal pure returns (uint256) {
require(_upperBound > 0, "UniformRand/min-bound");
uint256 min = -_upperBound % _upperBound;
uint256 random = _entropy;
while (true) {
if (random >= min) {
break;
}
random = uint256(keccak256(abi.encodePacked(random)));
}
return random % _upperBound;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "./ControlledTokenBuilder.sol";
import "../prize-strategy/multiple-winners/MultipleWinnersProxyFactory.sol";
/* solium-disable security/no-block-members */
contract MultipleWinnersBuilder {
event MultipleWinnersCreated(address indexed prizeStrategy);
struct MultipleWinnersConfig {
RNGInterface rngService;
uint256 prizePeriodStart;
uint256 prizePeriodSeconds;
string ticketName;
string ticketSymbol;
string sponsorshipName;
string sponsorshipSymbol;
uint256 ticketCreditLimitMantissa;
uint256 ticketCreditRateMantissa;
uint256 numberOfWinners;
bool splitExternalErc20Awards;
}
MultipleWinnersProxyFactory public multipleWinnersProxyFactory;
ControlledTokenBuilder public controlledTokenBuilder;
constructor (
MultipleWinnersProxyFactory _multipleWinnersProxyFactory,
ControlledTokenBuilder _controlledTokenBuilder
) public {
require(address(_multipleWinnersProxyFactory) != address(0), "MultipleWinnersBuilder/multipleWinnersProxyFactory-not-zero");
require(address(_controlledTokenBuilder) != address(0), "MultipleWinnersBuilder/token-builder-not-zero");
multipleWinnersProxyFactory = _multipleWinnersProxyFactory;
controlledTokenBuilder = _controlledTokenBuilder;
}
function createMultipleWinners(
PrizePool prizePool,
MultipleWinnersConfig memory prizeStrategyConfig,
uint8 decimals,
address owner
) external returns (MultipleWinners) {
MultipleWinners mw = multipleWinnersProxyFactory.create();
Ticket ticket = _createTicket(
prizeStrategyConfig.ticketName,
prizeStrategyConfig.ticketSymbol,
decimals,
prizePool
);
ControlledToken sponsorship = _createSponsorship(
prizeStrategyConfig.sponsorshipName,
prizeStrategyConfig.sponsorshipSymbol,
decimals,
prizePool
);
mw.initializeMultipleWinners(
prizeStrategyConfig.prizePeriodStart,
prizeStrategyConfig.prizePeriodSeconds,
prizePool,
ticket,
sponsorship,
prizeStrategyConfig.rngService,
prizeStrategyConfig.numberOfWinners
);
if (prizeStrategyConfig.splitExternalErc20Awards) {
mw.setSplitExternalErc20Awards(true);
}
mw.transferOwnership(owner);
emit MultipleWinnersCreated(address(mw));
return mw;
}
function createMultipleWinnersFromExistingPrizeStrategy(
PeriodicPrizeStrategy prizeStrategy,
uint256 numberOfWinners
) external returns (MultipleWinners) {
MultipleWinners mw = multipleWinnersProxyFactory.create();
mw.initializeMultipleWinners(
prizeStrategy.prizePeriodStartedAt(),
prizeStrategy.prizePeriodSeconds(),
prizeStrategy.prizePool(),
prizeStrategy.ticket(),
prizeStrategy.sponsorship(),
prizeStrategy.rng(),
numberOfWinners
);
mw.transferOwnership(msg.sender);
emit MultipleWinnersCreated(address(mw));
return mw;
}
function _createTicket(
string memory name,
string memory token,
uint8 decimals,
PrizePool prizePool
) internal returns (Ticket) {
return controlledTokenBuilder.createTicket(
ControlledTokenBuilder.ControlledTokenConfig(
name,
token,
decimals,
prizePool
)
);
}
function _createSponsorship(
string memory name,
string memory token,
uint8 decimals,
PrizePool prizePool
) internal returns (ControlledToken) {
return controlledTokenBuilder.createControlledToken(
ControlledTokenBuilder.ControlledTokenConfig(
name,
token,
decimals,
prizePool
)
);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "./MultipleWinners.sol";
import "../../external/openzeppelin/ProxyFactory.sol";
/// @title Creates a minimal proxy to the MultipleWinners prize strategy. Very cheap to deploy.
contract MultipleWinnersProxyFactory is ProxyFactory {
MultipleWinners public instance;
constructor () public {
instance = new MultipleWinners();
}
function create() external returns (MultipleWinners) {
return MultipleWinners(deployMinimal(address(instance), ""));
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
import "../PeriodicPrizeStrategy.sol";
contract MultipleWinners is PeriodicPrizeStrategy {
uint256 internal __numberOfWinners;
bool public splitExternalErc20Awards;
event SplitExternalErc20AwardsSet(bool splitExternalErc20Awards);
event NumberOfWinnersSet(uint256 numberOfWinners);
event NoWinners();
function initializeMultipleWinners (
uint256 _prizePeriodStart,
uint256 _prizePeriodSeconds,
PrizePool _prizePool,
TicketInterface _ticket,
IERC20Upgradeable _sponsorship,
RNGInterface _rng,
uint256 _numberOfWinners
) public initializer {
IERC20Upgradeable[] memory _externalErc20Awards;
PeriodicPrizeStrategy.initialize(
_prizePeriodStart,
_prizePeriodSeconds,
_prizePool,
_ticket,
_sponsorship,
_rng,
_externalErc20Awards
);
_setNumberOfWinners(_numberOfWinners);
}
function setSplitExternalErc20Awards(bool _splitExternalErc20Awards) external onlyOwner requireAwardNotInProgress {
splitExternalErc20Awards = _splitExternalErc20Awards;
emit SplitExternalErc20AwardsSet(splitExternalErc20Awards);
}
function setNumberOfWinners(uint256 count) external onlyOwner requireAwardNotInProgress {
_setNumberOfWinners(count);
}
function _setNumberOfWinners(uint256 count) internal {
require(count > 0, "MultipleWinners/winners-gte-one");
__numberOfWinners = count;
emit NumberOfWinnersSet(count);
}
function numberOfWinners() external view returns (uint256) {
return __numberOfWinners;
}
function _distribute(uint256 randomNumber) internal override {
uint256 prize = prizePool.captureAwardBalance();
// main winner is simply the first that is drawn
address mainWinner = ticket.draw(randomNumber);
// If drawing yields no winner, then there is no one to pick
if (mainWinner == address(0)) {
emit NoWinners();
return;
}
// main winner gets all external ERC721 tokens
_awardExternalErc721s(mainWinner);
address[] memory winners = new address[](__numberOfWinners);
winners[0] = mainWinner;
uint256 nextRandom = randomNumber;
for (uint256 winnerCount = 1; winnerCount < __numberOfWinners; winnerCount++) {
// add some arbitrary numbers to the previous random number to ensure no matches with the UniformRandomNumber lib
bytes32 nextRandomHash = keccak256(abi.encodePacked(nextRandom + 499 + winnerCount*521));
nextRandom = uint256(nextRandomHash);
winners[winnerCount] = ticket.draw(nextRandom);
}
// yield prize is split up among all winners
uint256 prizeShare = prize.div(winners.length);
if (prizeShare > 0) {
for (uint i = 0; i < winners.length; i++) {
_awardTickets(winners[i], prizeShare);
}
}
if (splitExternalErc20Awards) {
address currentToken = externalErc20s.start();
while (currentToken != address(0) && currentToken != externalErc20s.end()) {
uint256 balance = IERC20Upgradeable(currentToken).balanceOf(address(prizePool));
uint256 split = balance.div(__numberOfWinners);
if (split > 0) {
for (uint256 i = 0; i < winners.length; i++) {
prizePool.awardExternalERC20(winners[i], currentToken, split);
}
}
currentToken = externalErc20s.next(currentToken);
}
} else {
_awardExternalErc20s(mainWinner);
}
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts-upgradeable/utils/SafeCastUpgradeable.sol";
import "@nomiclabs/buidler/console.sol";
import "./CompoundPrizePoolBuilder.sol";
import "./VaultPrizePoolBuilder.sol";
import "./StakePrizePoolBuilder.sol";
import "./MultipleWinnersBuilder.sol";
contract PoolWithMultipleWinnersBuilder {
using SafeCastUpgradeable for uint256;
event CompoundPrizePoolWithMultipleWinnersCreated(address indexed prizePool, address indexed prizeStrategy);
event StakePrizePoolWithMultipleWinnersCreated(address indexed prizePool, address indexed prizeStrategy);
event VaultPrizePoolWithMultipleWinnersCreated(address indexed prizePool, address indexed prizeStrategy);
CompoundPrizePoolBuilder public compoundPrizePoolBuilder;
VaultPrizePoolBuilder public vaultPrizePoolBuilder;
StakePrizePoolBuilder public stakePrizePoolBuilder;
MultipleWinnersBuilder public multipleWinnersBuilder;
constructor (
CompoundPrizePoolBuilder _compoundPrizePoolBuilder,
VaultPrizePoolBuilder _vaultPrizePoolBuilder,
StakePrizePoolBuilder _stakePrizePoolBuilder,
MultipleWinnersBuilder _multipleWinnersBuilder
) public {
require(address(_compoundPrizePoolBuilder) != address(0), "GlobalBuilder/compoundPrizePoolBuilder-not-zero");
require(address(_vaultPrizePoolBuilder) != address(0), "GlobalBuilder/vaultPrizePoolBuilder-not-zero");
require(address(_stakePrizePoolBuilder) != address(0), "GlobalBuilder/stakePrizePoolBuilder-not-zero");
require(address(_multipleWinnersBuilder) != address(0), "GlobalBuilder/multipleWinnersBuilder-not-zero");
compoundPrizePoolBuilder = _compoundPrizePoolBuilder;
vaultPrizePoolBuilder = _vaultPrizePoolBuilder;
stakePrizePoolBuilder = _stakePrizePoolBuilder;
multipleWinnersBuilder = _multipleWinnersBuilder;
}
function createCompoundMultipleWinners(
CompoundPrizePoolBuilder.CompoundPrizePoolConfig memory prizePoolConfig,
MultipleWinnersBuilder.MultipleWinnersConfig memory prizeStrategyConfig,
uint8 decimals
) external returns (CompoundPrizePool) {
CompoundPrizePool prizePool = compoundPrizePoolBuilder.createCompoundPrizePool(prizePoolConfig);
MultipleWinners prizeStrategy = _createMultipleWinnersAndTransferPrizePool(prizePool, prizeStrategyConfig, decimals);
emit CompoundPrizePoolWithMultipleWinnersCreated(address(prizePool), address(prizeStrategy));
return prizePool;
}
function createStakeMultipleWinners(
StakePrizePoolBuilder.StakePrizePoolConfig memory prizePoolConfig,
MultipleWinnersBuilder.MultipleWinnersConfig memory prizeStrategyConfig,
uint8 decimals
) external returns (StakePrizePool) {
StakePrizePool prizePool = stakePrizePoolBuilder.createStakePrizePool(prizePoolConfig);
MultipleWinners prizeStrategy = _createMultipleWinnersAndTransferPrizePool(prizePool, prizeStrategyConfig, decimals);
emit StakePrizePoolWithMultipleWinnersCreated(address(prizePool), address(prizeStrategy));
return prizePool;
}
function createVaultMultipleWinners(
VaultPrizePoolBuilder.VaultPrizePoolConfig memory prizePoolConfig,
MultipleWinnersBuilder.MultipleWinnersConfig memory prizeStrategyConfig,
uint8 decimals
) external returns (yVaultPrizePool) {
yVaultPrizePool prizePool = vaultPrizePoolBuilder.createVaultPrizePool(prizePoolConfig);
MultipleWinners prizeStrategy = _createMultipleWinnersAndTransferPrizePool(prizePool, prizeStrategyConfig, decimals);
emit VaultPrizePoolWithMultipleWinnersCreated(address(prizePool), address(prizeStrategy));
return prizePool;
}
function _createMultipleWinnersAndTransferPrizePool(
PrizePool prizePool,
MultipleWinnersBuilder.MultipleWinnersConfig memory prizeStrategyConfig,
uint8 decimals
) internal returns (MultipleWinners) {
MultipleWinners periodicPrizeStrategy = multipleWinnersBuilder.createMultipleWinners(
prizePool,
prizeStrategyConfig,
decimals,
msg.sender
);
address ticket = address(periodicPrizeStrategy.ticket());
prizePool.setPrizeStrategy(periodicPrizeStrategy);
prizePool.addControlledToken(Ticket(ticket));
prizePool.addControlledToken(ControlledTokenInterface(address(periodicPrizeStrategy.sponsorship())));
prizePool.setCreditPlanOf(
ticket,
prizeStrategyConfig.ticketCreditRateMantissa.toUint128(),
prizeStrategyConfig.ticketCreditLimitMantissa.toUint128()
);
prizePool.transferOwnership(msg.sender);
return periodicPrizeStrategy;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >= 0.4.22 <0.8.0;
library console {
address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
function _sendLogPayload(bytes memory payload) private view {
uint256 payloadLength = payload.length;
address consoleAddress = CONSOLE_ADDRESS;
assembly {
let payloadStart := add(payload, 32)
let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
}
}
function log() internal view {
_sendLogPayload(abi.encodeWithSignature("log()"));
}
function logInt(int p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
}
function logUint(uint p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
}
function logString(string memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function logBool(bool p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function logAddress(address p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function logBytes(bytes memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
}
function logByte(byte p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(byte)", p0));
}
function logBytes1(bytes1 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
}
function logBytes2(bytes2 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
}
function logBytes3(bytes3 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
}
function logBytes4(bytes4 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
}
function logBytes5(bytes5 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
}
function logBytes6(bytes6 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
}
function logBytes7(bytes7 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
}
function logBytes8(bytes8 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
}
function logBytes9(bytes9 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
}
function logBytes10(bytes10 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
}
function logBytes11(bytes11 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
}
function logBytes12(bytes12 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
}
function logBytes13(bytes13 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
}
function logBytes14(bytes14 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
}
function logBytes15(bytes15 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
}
function logBytes16(bytes16 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
}
function logBytes17(bytes17 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
}
function logBytes18(bytes18 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
}
function logBytes19(bytes19 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
}
function logBytes20(bytes20 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
}
function logBytes21(bytes21 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
}
function logBytes22(bytes22 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
}
function logBytes23(bytes23 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
}
function logBytes24(bytes24 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
}
function logBytes25(bytes25 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
}
function logBytes26(bytes26 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
}
function logBytes27(bytes27 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
}
function logBytes28(bytes28 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
}
function logBytes29(bytes29 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
}
function logBytes30(bytes30 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
}
function logBytes31(bytes31 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
}
function logBytes32(bytes32 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
}
function log(uint p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
}
function log(string memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function log(bool p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function log(address p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function log(uint p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
}
function log(uint p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
}
function log(uint p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
}
function log(uint p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
}
function log(string memory p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
}
function log(string memory p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
}
function log(string memory p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
}
function log(string memory p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
}
function log(bool p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
}
function log(bool p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
}
function log(bool p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
}
function log(bool p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
}
function log(address p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
}
function log(address p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
}
function log(address p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
}
function log(address p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
}
function log(uint p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
}
function log(uint p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
}
function log(uint p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
}
function log(uint p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
}
function log(uint p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
}
function log(uint p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
}
function log(uint p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
}
function log(uint p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
}
function log(uint p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
}
function log(uint p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
}
function log(uint p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
}
function log(uint p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
}
function log(uint p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
}
function log(uint p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
}
function log(uint p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
}
function log(uint p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
}
function log(string memory p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
}
function log(string memory p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
}
function log(string memory p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
}
function log(string memory p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
}
function log(string memory p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
}
function log(string memory p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
}
function log(string memory p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
}
function log(string memory p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
}
function log(string memory p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
}
function log(string memory p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
}
function log(string memory p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
}
function log(string memory p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
}
function log(string memory p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
}
function log(string memory p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
}
function log(string memory p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
}
function log(string memory p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
}
function log(bool p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
}
function log(bool p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
}
function log(bool p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
}
function log(bool p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
}
function log(bool p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
}
function log(bool p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
}
function log(bool p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
}
function log(bool p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
}
function log(bool p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
}
function log(bool p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
}
function log(bool p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
}
function log(bool p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
}
function log(bool p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
}
function log(bool p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
}
function log(bool p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
}
function log(bool p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
}
function log(address p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
}
function log(address p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
}
function log(address p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
}
function log(address p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
}
function log(address p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
}
function log(address p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
}
function log(address p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
}
function log(address p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
}
function log(address p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
}
function log(address p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
}
function log(address p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
}
function log(address p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
}
function log(address p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
}
function log(address p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
}
function log(address p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
}
function log(address p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
}
function log(uint p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "../registry/RegistryInterface.sol";
import "./PrizePoolBuilder.sol";
import "../prize-pool/yearn/yVaultPrizePoolProxyFactory.sol";
import "../external/yearn/yVaultInterface.sol";
import "../external/openzeppelin/OpenZeppelinProxyFactoryInterface.sol";
/* solium-disable security/no-block-members */
contract VaultPrizePoolBuilder is PrizePoolBuilder {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
struct VaultPrizePoolConfig {
yVaultInterface vault;
uint256 reserveRateMantissa;
uint256 maxExitFeeMantissa;
uint256 maxTimelockDuration;
}
RegistryInterface public reserveRegistry;
yVaultPrizePoolProxyFactory public vaultPrizePoolProxyFactory;
constructor (
RegistryInterface _reserveRegistry,
yVaultPrizePoolProxyFactory _vaultPrizePoolProxyFactory
) public {
require(address(_reserveRegistry) != address(0), "VaultPrizePoolBuilder/reserveRegistry-not-zero");
require(address(_vaultPrizePoolProxyFactory) != address(0), "VaultPrizePoolBuilder/compound-prize-pool-builder-not-zero");
reserveRegistry = _reserveRegistry;
vaultPrizePoolProxyFactory = _vaultPrizePoolProxyFactory;
}
function createVaultPrizePool(
VaultPrizePoolConfig calldata config
)
external
returns (yVaultPrizePool)
{
yVaultPrizePool prizePool = vaultPrizePoolProxyFactory.create();
ControlledTokenInterface[] memory tokens;
prizePool.initialize(
reserveRegistry,
tokens,
config.maxExitFeeMantissa,
config.maxTimelockDuration,
config.vault,
config.reserveRateMantissa
);
prizePool.transferOwnership(msg.sender);
emit PrizePoolCreated(msg.sender, address(prizePool));
return prizePool;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "./yVaultPrizePool.sol";
import "../../external/openzeppelin/ProxyFactory.sol";
/// @title yVault Prize Pool Proxy Factory
/// @notice Minimal proxy pattern for creating new yVault Prize Pools
contract yVaultPrizePoolProxyFactory is ProxyFactory {
/// @notice Contract template for deploying proxied Prize Pools
yVaultPrizePool public instance;
/// @notice Initializes the Factory with an instance of the yVault Prize Pool
constructor () public {
instance = new yVaultPrizePool();
}
/// @notice Creates a new yVault Prize Pool as a proxy of the template instance
/// @return A reference to the new proxied yVault Prize Pool
function create() external returns (yVaultPrizePool) {
return yVaultPrizePool(deployMinimal(address(instance), ""));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "../../external/yearn/yVaultInterface.sol";
import "../PrizePool.sol";
/// @title Prize Pool for yEarn's yVaults
contract yVaultPrizePool is PrizePool {
using SafeMathUpgradeable for uint256;
event yVaultPrizePoolInitialized(address indexed vault);
event ReserveRateMantissaSet(uint256 reserveRateMantissa);
/// @notice Interface for the yEarn yVault
yVaultInterface public vault;
/// Amount that is never exposed to the prize
uint256 public reserveRateMantissa;
/// @notice Initializes the Prize Pool and Yield Service with the required contract connections
/// @param _controlledTokens Array of addresses for the Ticket and Sponsorship Tokens controlled by the Prize Pool
/// @param _maxExitFeeMantissa The maximum exit fee size, relative to the withdrawal amount
/// @param _maxTimelockDuration The maximum length of time the withdraw timelock could be
/// @param _vault Address of the yEarn yVaultInterface
function initialize (
RegistryInterface _reserveRegistry,
ControlledTokenInterface[] memory _controlledTokens,
uint256 _maxExitFeeMantissa,
uint256 _maxTimelockDuration,
yVaultInterface _vault,
uint256 _reserveRateMantissa
)
public
initializer
{
PrizePool.initialize(
_reserveRegistry,
_controlledTokens,
_maxExitFeeMantissa,
_maxTimelockDuration
);
vault = _vault;
_setReserveRateMantissa(_reserveRateMantissa);
emit yVaultPrizePoolInitialized(address(vault));
}
function setReserveRateMantissa(uint256 _reserveRateMantissa) external onlyOwner {
_setReserveRateMantissa(_reserveRateMantissa);
}
function _setReserveRateMantissa(uint256 _reserveRateMantissa) internal {
require(_reserveRateMantissa < 1 ether, "yVaultPrizePool/reserve-rate-lt-one");
reserveRateMantissa = _reserveRateMantissa;
emit ReserveRateMantissaSet(reserveRateMantissa);
}
/// @dev Gets the balance of the underlying assets held by the Yield Service
/// @return The underlying balance of asset tokens
function _balance() internal override returns (uint256) {
uint256 total = _sharesToToken(vault.balanceOf(address(this)));
uint256 reserve = FixedPoint.multiplyUintByMantissa(total, reserveRateMantissa);
return total.sub(reserve);
}
/// @dev Allows a user to supply asset tokens in exchange for yield-bearing tokens
/// to be held in escrow by the Yield Service
function _supply(uint256) internal override {
IERC20Upgradeable assetToken = _token();
uint256 total = assetToken.balanceOf(address(this));
assetToken.approve(address(vault), total);
vault.deposit(total);
}
/// @dev Allows a user to supply asset tokens in exchange for yield-bearing tokens
/// to be held in escrow by the Yield Service
function _supplySpecific(uint256 amount) internal {
_token().approve(address(vault), amount);
vault.deposit(amount);
}
/// @dev The external token cannot be yDai or Dai
/// @param _externalToken The address of the token to check
/// @return True if the token may be awarded, false otherwise
function _canAwardExternal(address _externalToken) internal override view returns (bool) {
return _externalToken != address(vault) && _externalToken != address(vault.token());
}
/// @dev Allows a user to redeem yield-bearing tokens in exchange for the underlying
/// asset tokens held in escrow by the Yield Service
/// @param amount The amount of underlying tokens to be redeemed
/// @return The actual amount of tokens transferred
function _redeem(uint256 amount) internal override returns (uint256) {
IERC20Upgradeable token = _token();
require(_balance() >= amount, "yVaultPrizePool/insuff-liquidity");
// yVault will try to over-withdraw so that amount is always available
// we want: amount = X - X*feeRate
// amount = X(1 - feeRate)
// amount / (1 - feeRate) = X
// calculate possible fee
uint256 withdrawal;
if (reserveRateMantissa > 0) {
withdrawal = FixedPoint.divideUintByMantissa(amount, uint256(1e18).sub(reserveRateMantissa));
} else {
withdrawal = amount;
}
uint256 sharesToWithdraw = _tokenToShares(withdrawal);
uint256 preBalance = token.balanceOf(address(this));
vault.withdraw(sharesToWithdraw);
uint256 postBalance = token.balanceOf(address(this));
uint256 amountWithdrawn = postBalance.sub(preBalance);
uint256 amountRedeemable = (amountWithdrawn < amount) ? amountWithdrawn : amount;
// Redeposit any asset funds that were removed preemptively for fees
if (postBalance > amountRedeemable) {
_supplySpecific(postBalance.sub(amountRedeemable));
}
return amountRedeemable;
}
function _tokenToShares(uint256 tokens) internal view returns (uint256) {
/**
ex. rate = tokens / shares
=> shares = shares_total * (tokens / tokens total)
*/
return vault.totalSupply().mul(tokens).div(vault.balance());
}
function _sharesToToken(uint256 shares) internal view returns (uint256) {
uint256 ts = vault.totalSupply();
if (ts == 0 || shares == 0) {
return 0;
}
return (vault.balance().mul(shares)).div(ts);
}
/// @dev Gets the underlying asset token used by the Yield Service
/// @return A reference to the interface of the underling asset token
function _token() internal override view returns (IERC20Upgradeable) {
return IERC20Upgradeable(vault.token());
}
}
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
interface yVaultInterface is IERC20Upgradeable {
function token() external view returns (IERC20Upgradeable);
function balance() external view returns (uint256);
function deposit(uint256 _amount) external;
function withdraw(uint256 _shares) external;
function getPricePerFullShare() external view returns (uint256);
}
pragma solidity >=0.6.0 <0.7.0;
interface OpenZeppelinProxyFactoryInterface {
function deploy(uint256 _salt, address _logic, address _admin, bytes calldata _data) external returns (address);
function getDeploymentAddress(uint256 _salt, address _sender) external view returns (address);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "./PrizePoolBuilder.sol";
import "../registry/RegistryInterface.sol";
import "../builders/MultipleWinnersBuilder.sol";
import "../prize-pool/stake/StakePrizePoolProxyFactory.sol";
/* solium-disable security/no-block-members */
contract StakePrizePoolBuilder is PrizePoolBuilder {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
struct StakePrizePoolConfig {
IERC20Upgradeable token;
uint256 maxExitFeeMantissa;
uint256 maxTimelockDuration;
}
RegistryInterface public reserveRegistry;
StakePrizePoolProxyFactory public stakePrizePoolProxyFactory;
constructor (
RegistryInterface _reserveRegistry,
StakePrizePoolProxyFactory _stakePrizePoolProxyFactory
) public {
require(address(_reserveRegistry) != address(0), "StakePrizePoolBuilder/reserveRegistry-not-zero");
require(address(_stakePrizePoolProxyFactory) != address(0), "StakePrizePoolBuilder/stake-prize-pool-proxy-factory-not-zero");
reserveRegistry = _reserveRegistry;
stakePrizePoolProxyFactory = _stakePrizePoolProxyFactory;
}
function createStakePrizePool(
StakePrizePoolConfig calldata config
)
external
returns (StakePrizePool)
{
StakePrizePool prizePool = stakePrizePoolProxyFactory.create();
ControlledTokenInterface[] memory tokens;
prizePool.initialize(
reserveRegistry,
tokens,
config.maxExitFeeMantissa,
config.maxTimelockDuration,
config.token
);
prizePool.transferOwnership(msg.sender);
emit PrizePoolCreated(msg.sender, address(prizePool));
return prizePool;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "./StakePrizePool.sol";
import "../../external/openzeppelin/ProxyFactory.sol";
/// @title Stake Prize Pool Proxy Factory
/// @notice Minimal proxy pattern for creating new yVault Prize Pools
contract StakePrizePoolProxyFactory is ProxyFactory {
/// @notice Contract template for deploying proxied Prize Pools
StakePrizePool public instance;
/// @notice Initializes the Factory with an instance of the yVault Prize Pool
constructor () public {
instance = new StakePrizePool();
}
/// @notice Creates a new Stake Prize Pool as a proxy of the template instance
/// @return A reference to the new proxied Stake Prize Pool
function create() external returns (StakePrizePool) {
return StakePrizePool(deployMinimal(address(instance), ""));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "../PrizePool.sol";
contract StakePrizePool is PrizePool {
IERC20Upgradeable private stakeToken;
event StakePrizePoolInitialized(address indexed stakeToken);
/// @notice Initializes the Prize Pool and Yield Service with the required contract connections
/// @param _controlledTokens Array of addresses for the Ticket and Sponsorship Tokens controlled by the Prize Pool
/// @param _maxExitFeeMantissa The maximum exit fee size, relative to the withdrawal amount
/// @param _maxTimelockDuration The maximum length of time the withdraw timelock could be
/// @param _stakeToken Address of the stake token
function initialize (
RegistryInterface _reserveRegistry,
ControlledTokenInterface[] memory _controlledTokens,
uint256 _maxExitFeeMantissa,
uint256 _maxTimelockDuration,
IERC20Upgradeable _stakeToken
)
public
initializer
{
PrizePool.initialize(
_reserveRegistry,
_controlledTokens,
_maxExitFeeMantissa,
_maxTimelockDuration
);
stakeToken = _stakeToken;
emit StakePrizePoolInitialized(address(stakeToken));
}
/// @notice Determines whether the passed token can be transferred out as an external award.
/// @dev Different yield sources will hold the deposits as another kind of token: such a Compound's cToken. The
/// prize strategy should not be allowed to move those tokens.
/// @param _externalToken The address of the token to check
/// @return True if the token may be awarded, false otherwise
function _canAwardExternal(address _externalToken) internal override view returns (bool) {
return address(stakeToken) != _externalToken;
}
/// @notice Returns the total balance (in asset tokens). This includes the deposits and interest.
/// @return The underlying balance of asset tokens
function _balance() internal override returns (uint256) {
return stakeToken.balanceOf(address(this));
}
function _token() internal override view returns (IERC20Upgradeable) {
return stakeToken;
}
/// @notice Supplies asset tokens to the yield source.
/// @param mintAmount The amount of asset tokens to be supplied
function _supply(uint256 mintAmount) internal override {
// no-op because nothing else needs to be done
}
/// @notice Redeems asset tokens from the yield source.
/// @param redeemAmount The amount of yield-bearing tokens to be redeemed
/// @return The actual amount of tokens that were redeemed.
function _redeem(uint256 redeemAmount) internal override returns (uint256) {
return redeemAmount;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts-upgradeable/utils/SafeCastUpgradeable.sol";
import "../utils/UInt256Array.sol";
import "./ComptrollerStorage.sol";
import "../token/TokenListener.sol";
/// @title The Comptroller disburses rewards to pool users
/* solium-disable security/no-block-members */
contract Comptroller is ComptrollerStorage, TokenListener {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
using UInt256Array for uint256[];
using ExtendedSafeCast for uint256;
using BalanceDrip for BalanceDrip.State;
using VolumeDrip for VolumeDrip.State;
using BalanceDripManager for BalanceDripManager.State;
using VolumeDripManager for VolumeDripManager.State;
using MappedSinglyLinkedList for MappedSinglyLinkedList.Mapping;
/// @notice Emitted when a balance drip is actived
event BalanceDripActivated(
address indexed source,
address indexed measure,
address indexed dripToken,
uint256 dripRatePerSecond
);
/// @notice Emitted when a balance drip is deactivated
event BalanceDripDeactivated(
address indexed source,
address indexed measure,
address indexed dripToken
);
/// @notice Emitted when a balance drip rate is updated
event BalanceDripRateSet(
address indexed source,
address indexed measure,
address indexed dripToken,
uint256 dripRatePerSecond
);
/// @notice Emitted when a balance drip drips tokens
event BalanceDripDripped(
address indexed source,
address indexed measure,
address indexed dripToken,
address user,
uint256 amount
);
event DripTokenDripped(
address indexed dripToken,
address indexed user,
uint256 amount
);
/// @notice Emitted when a volue drip drips tokens
event VolumeDripDripped(
address indexed source,
address indexed measure,
address indexed dripToken,
bool isReferral,
address user,
uint256 amount
);
/// @notice Emitted when a user claims drip tokens
event DripTokenClaimed(
address indexed operator,
address indexed dripToken,
address indexed user,
uint256 amount
);
/// @notice Emitted when a volume drip is activated
event VolumeDripActivated(
address indexed source,
address indexed measure,
address indexed dripToken,
bool isReferral,
uint256 periodSeconds,
uint256 dripAmount
);
event TransferredOut(
address indexed token,
address indexed to,
uint256 amount
);
/// @notice Emitted when a new volume drip period has started
event VolumeDripPeriodStarted(
address indexed source,
address indexed measure,
address indexed dripToken,
bool isReferral,
uint32 period,
uint256 dripAmount,
uint256 endTime
);
/// @notice Emitted when a volume drip period has ended
event VolumeDripPeriodEnded(
address indexed source,
address indexed measure,
address indexed dripToken,
bool isReferral,
uint32 period,
uint256 totalSupply,
uint256 drippedTokens
);
/// @notice Emitted when a volume drip is updated
event VolumeDripSet(
address indexed source,
address indexed measure,
address indexed dripToken,
bool isReferral,
uint256 periodSeconds,
uint256 dripAmount
);
/// @notice Emitted when a volume drip is deactivated.
event VolumeDripDeactivated(
address indexed source,
address indexed measure,
address indexed dripToken,
bool isReferral
);
/// @notice Convenience struct used when updating drips
struct UpdatePair {
address source;
address measure;
}
/// @notice Convenience struct used to retrieve balances after updating drips
struct DripTokenBalance {
address dripToken;
uint256 balance;
}
/// @notice Initializes a new Comptroller.
constructor () public {
__Ownable_init();
}
function transferOut(address token, address to, uint256 amount) external onlyOwner {
IERC20Upgradeable(token).transfer(to, amount);
emit TransferredOut(token, to, amount);
}
/// @notice Activates a balance drip. Only callable by the owner.
/// @param source The balance drip "source"; i.e. a Prize Pool address.
/// @param measure The ERC20 token whose balances determines user's share of the drip rate.
/// @param dripToken The token that is dripped to users.
/// @param dripRatePerSecond The amount of drip tokens that are awarded each second to the total supply of measure.
function activateBalanceDrip(address source, address measure, address dripToken, uint256 dripRatePerSecond) external onlyOwner {
balanceDrips[source].activateDrip(measure, dripToken, dripRatePerSecond);
emit BalanceDripActivated(
source,
measure,
dripToken,
dripRatePerSecond
);
}
/// @notice Deactivates a balance drip. Only callable by the owner.
/// @param source The balance drip "source"; i.e. a Prize Pool address.
/// @param measure The ERC20 token whose balances determines user's share of the drip rate.
/// @param dripToken The token that is dripped to users.
/// @param prevDripToken The previous drip token in the balance drip list. If the dripToken is the first address,
/// then the previous address is the SENTINEL address: 0x0000000000000000000000000000000000000001
function deactivateBalanceDrip(address source, address measure, address dripToken, address prevDripToken) external onlyOwner {
_deactivateBalanceDrip(source, measure, dripToken, prevDripToken);
}
/// @notice Deactivates a balance drip. Only callable by the owner.
/// @param source The balance drip "source"; i.e. a Prize Pool address.
/// @param measure The ERC20 token whose balances determines user's share of the drip rate.
/// @param dripToken The token that is dripped to users.
/// @param prevDripToken The previous drip token in the balance drip list. If the dripToken is the first address,
/// then the previous address is the SENTINEL address: 0x0000000000000000000000000000000000000001
function _deactivateBalanceDrip(address source, address measure, address dripToken, address prevDripToken) internal {
balanceDrips[source].deactivateDrip(measure, dripToken, prevDripToken, _currentTime().toUint32(), _availableDripTokenBalance(dripToken));
emit BalanceDripDeactivated(source, measure, dripToken);
}
/// @notice Gets a list of active balance drip tokens
/// @param source The balance drip "source"; i.e. a Prize Pool address.
/// @param measure The ERC20 token whose balances determines user's share of the drip rate.
/// @return An array of active Balance Drip token addresses
function getActiveBalanceDripTokens(address source, address measure) external view returns (address[] memory) {
return balanceDrips[source].getActiveBalanceDrips(measure);
}
/// @notice Returns the state of a balance drip.
/// @param source The balance drip "source"; i.e. Prize Pool
/// @param measure The token that measure's a users share of the drip
/// @param dripToken The token that is being dripped to users
/// @return dripRatePerSecond The current drip rate of the balance drip.
/// @return exchangeRateMantissa The current exchange rate from measure to dripTokens
/// @return timestamp The timestamp at which the balance drip was last updated.
function getBalanceDrip(
address source,
address measure,
address dripToken
)
external
view
returns (
uint256 dripRatePerSecond,
uint128 exchangeRateMantissa,
uint32 timestamp
)
{
BalanceDrip.State storage balanceDrip = balanceDrips[source].getDrip(measure, dripToken);
dripRatePerSecond = balanceDrip.dripRatePerSecond;
exchangeRateMantissa = balanceDrip.exchangeRateMantissa;
timestamp = balanceDrip.timestamp;
}
/// @notice Sets the drip rate for a balance drip. The drip rate is the number of drip tokens given to the
/// entire supply of measure tokens. Only callable by the owner.
/// @param source The balance drip "source"; i.e. Prize Pool
/// @param measure The token to use to measure a user's share of the drip rate
/// @param dripToken The token that is dripped to the user
/// @param dripRatePerSecond The new drip rate per second
function setBalanceDripRate(address source, address measure, address dripToken, uint256 dripRatePerSecond) external onlyOwner {
balanceDrips[source].setDripRate(measure, dripToken, dripRatePerSecond, _currentTime().toUint32(), _availableDripTokenBalance(dripToken));
emit BalanceDripRateSet(
source,
measure,
dripToken,
dripRatePerSecond
);
}
/// @notice Activates a volume drip. Volume drips distribute tokens to users based on their share of the activity within a period.
/// @param source The Prize Pool for which to bind to
/// @param measure The Prize Pool controlled token whose volume should be measured
/// @param dripToken The token that is being disbursed
/// @param isReferral Whether this volume drip is for referrals
/// @param periodSeconds The period of the volume drip, in seconds
/// @param dripAmount The amount of dripTokens disbursed each period.
/// @param endTime The time at which the first period ends.
function activateVolumeDrip(
address source,
address measure,
address dripToken,
bool isReferral,
uint32 periodSeconds,
uint112 dripAmount,
uint32 endTime
)
external
onlyOwner
{
uint32 period;
if (isReferral) {
period = referralVolumeDrips[source].activate(measure, dripToken, periodSeconds, dripAmount, endTime);
} else {
period = volumeDrips[source].activate(measure, dripToken, periodSeconds, dripAmount, endTime);
}
emit VolumeDripActivated(
source,
measure,
dripToken,
isReferral,
periodSeconds,
dripAmount
);
emit VolumeDripPeriodStarted(
source,
measure,
dripToken,
isReferral,
period,
dripAmount,
endTime
);
}
/// @notice Deactivates a volume drip. Volume drips distribute tokens to users based on their share of the activity within a period.
/// @param source The Prize Pool for which to bind to
/// @param measure The Prize Pool controlled token whose volume should be measured
/// @param dripToken The token that is being disbursed
/// @param isReferral Whether this volume drip is for referrals
/// @param prevDripToken The previous drip token in the volume drip list. Is different for referrals vs non-referral volume drips.
function deactivateVolumeDrip(
address source,
address measure,
address dripToken,
bool isReferral,
address prevDripToken
)
external
onlyOwner
{
_deactivateVolumeDrip(source, measure, dripToken, isReferral, prevDripToken);
}
/// @notice Deactivates a volume drip. Volume drips distribute tokens to users based on their share of the activity within a period.
/// @param source The Prize Pool for which to bind to
/// @param measure The Prize Pool controlled token whose volume should be measured
/// @param dripToken The token that is being disbursed
/// @param isReferral Whether this volume drip is for referrals
/// @param prevDripToken The previous drip token in the volume drip list. Is different for referrals vs non-referral volume drips.
function _deactivateVolumeDrip(
address source,
address measure,
address dripToken,
bool isReferral,
address prevDripToken
)
internal
{
if (isReferral) {
referralVolumeDrips[source].deactivate(measure, dripToken, prevDripToken);
} else {
volumeDrips[source].deactivate(measure, dripToken, prevDripToken);
}
emit VolumeDripDeactivated(
source,
measure,
dripToken,
isReferral
);
}
/// @notice Sets the parameters for the *next* volume drip period. The source, measure, dripToken and isReferral combined
/// are used to uniquely identify a volume drip. Only callable by the owner.
/// @param source The Prize Pool of the volume drip
/// @param measure The token whose volume is being measured
/// @param dripToken The token that is being disbursed
/// @param isReferral Whether this volume drip is a referral
/// @param periodSeconds The length to use for the next period
/// @param dripAmount The amount of tokens to drip for the next period
function setVolumeDrip(
address source,
address measure,
address dripToken,
bool isReferral,
uint32 periodSeconds,
uint112 dripAmount
)
external
onlyOwner
{
if (isReferral) {
referralVolumeDrips[source].set(measure, dripToken, periodSeconds, dripAmount);
} else {
volumeDrips[source].set(measure, dripToken, periodSeconds, dripAmount);
}
emit VolumeDripSet(
source,
measure,
dripToken,
isReferral,
periodSeconds,
dripAmount
);
}
function getVolumeDrip(
address source,
address measure,
address dripToken,
bool isReferral
)
external
view
returns (
uint256 periodSeconds,
uint256 dripAmount,
uint256 periodCount
)
{
VolumeDrip.State memory drip;
if (isReferral) {
drip = referralVolumeDrips[source].volumeDrips[measure][dripToken];
} else {
drip = volumeDrips[source].volumeDrips[measure][dripToken];
}
return (
drip.nextPeriodSeconds,
drip.nextDripAmount,
drip.periodCount
);
}
/// @notice Gets a list of active volume drip tokens
/// @param source The volume drip "source"; i.e. a Prize Pool address.
/// @param measure The ERC20 token whose volume determines user's share of the drip rate.
/// @param isReferral Whether this volume drip is a referral
/// @return An array of active Volume Drip token addresses
function getActiveVolumeDripTokens(address source, address measure, bool isReferral) external view returns (address[] memory) {
if (isReferral) {
return referralVolumeDrips[source].getActiveVolumeDrips(measure);
} else {
return volumeDrips[source].getActiveVolumeDrips(measure);
}
}
function isVolumeDripActive(
address source,
address measure,
address dripToken,
bool isReferral
)
external
view
returns (bool)
{
if (isReferral) {
return referralVolumeDrips[source].isActive(measure, dripToken);
} else {
return volumeDrips[source].isActive(measure, dripToken);
}
}
function getVolumeDripPeriod(
address source,
address measure,
address dripToken,
bool isReferral,
uint16 period
)
external
view
returns (
uint112 totalSupply,
uint112 dripAmount,
uint32 endTime
)
{
VolumeDrip.Period memory periodState;
if (isReferral) {
periodState = referralVolumeDrips[source].volumeDrips[measure][dripToken].periods[period];
} else {
periodState = volumeDrips[source].volumeDrips[measure][dripToken].periods[period];
}
return (
periodState.totalSupply,
periodState.dripAmount,
periodState.endTime
);
}
/// @notice Returns a users claimable balance of drip tokens. This is the combination of all balance and volume drips.
/// @param dripToken The token that is being disbursed
/// @param user The user whose balance should be checked.
/// @return The claimable balance of the dripToken by the user.
function balanceOfDrip(address user, address dripToken) external view returns (uint256) {
return dripTokenBalances[dripToken][user];
}
/// @notice Claims a drip token on behalf of a user. If the passed amount is less than or equal to the users drip balance, then
/// they will be transferred that amount. Otherwise, it fails.
/// @param user The user for whom to claim the drip tokens
/// @param dripToken The drip token to claim
/// @param amount The amount of drip token to claim
function claimDrip(address user, address dripToken, uint256 amount) public {
address sender = _msgSender();
dripTokenTotalSupply[dripToken] = dripTokenTotalSupply[dripToken].sub(amount);
dripTokenBalances[dripToken][user] = dripTokenBalances[dripToken][user].sub(amount);
require(IERC20Upgradeable(dripToken).transfer(user, amount), "Comptroller/claim-transfer-failed");
emit DripTokenClaimed(sender, dripToken, user, amount);
}
function claimDrips(address user, address[] memory dripTokens) public {
for (uint i = 0; i < dripTokens.length; i++) {
claimDrip(user, dripTokens[i], dripTokenBalances[dripTokens[i]][user]);
}
}
function updateActiveBalanceDripsForPairs(
UpdatePair[] memory pairs
) public {
uint256 currentTime = _currentTime();
uint256 i;
for (i = 0; i < pairs.length; i++) {
UpdatePair memory pair = pairs[i];
_updateActiveBalanceDrips(
balanceDrips[pair.source],
pair.source,
pair.measure,
IERC20Upgradeable(pair.measure).totalSupply(),
currentTime
);
}
}
function updateActiveVolumeDripsForPairs(
UpdatePair[] memory pairs
) public {
uint256 i;
for (i = 0; i < pairs.length; i++) {
UpdatePair memory pair = pairs[i];
_updateActiveVolumeDrips(
volumeDrips[pair.source],
pair.source,
pair.measure,
false
);
_updateActiveVolumeDrips(
referralVolumeDrips[pair.source],
pair.source,
pair.measure,
true
);
}
}
function mintAndCaptureVolumeDripsForPairs(
UpdatePair[] memory pairs,
address user,
uint256 amount,
address[] memory dripTokens
) public {
uint256 i;
for (i = 0; i < pairs.length; i++) {
UpdatePair memory pair = pairs[i];
_mintAndCaptureForVolumeDrips(pair.source, pair.measure, user, amount, dripTokens);
_mintAndCaptureReferralVolumeDrips(pair.source, pair.measure, user, amount, dripTokens);
}
}
function _mintAndCaptureForVolumeDrips(
address source,
address measure,
address user,
uint256 amount,
address[] memory dripTokens
) internal {
uint i;
for (i = 0; i < dripTokens.length; i++) {
address dripToken = dripTokens[i];
VolumeDrip.State storage state = volumeDrips[source].volumeDrips[measure][dripToken];
_captureClaimForVolumeDrip(state, source, measure, dripToken, false, user, amount);
}
}
function _mintAndCaptureReferralVolumeDrips(
address source,
address measure,
address user,
uint256 amount,
address[] memory dripTokens
) internal {
uint i;
for (i = 0; i < dripTokens.length; i++) {
address dripToken = dripTokens[i];
VolumeDrip.State storage referralState = referralVolumeDrips[source].volumeDrips[measure][dripToken];
_captureClaimForVolumeDrip(referralState, source, measure, dripToken, true, user, amount);
}
}
function _captureClaimForVolumeDrip(
VolumeDrip.State storage dripState,
address source,
address measure,
address dripToken,
bool isReferral,
address user,
uint256 amount
) internal {
uint256 newUserTokens = dripState.mint(
user,
amount
);
if (newUserTokens > 0) {
_addDripBalance(dripToken, user, newUserTokens);
emit VolumeDripDripped(source, measure, dripToken, isReferral, user, newUserTokens);
}
}
/// @param pairs The (source, measure) pairs to update. For each pair all of the balance drips, volume drips, and referral volume drips will be updated.
/// @param user The user whose drips and balances will be updated.
/// @param dripTokens The drip tokens to retrieve claim balances for.
function captureClaimsForBalanceDripsForPairs(
UpdatePair[] memory pairs,
address user,
address[] memory dripTokens
)
public
{
uint256 i;
for (i = 0; i < pairs.length; i++) {
UpdatePair memory pair = pairs[i];
uint256 measureBalance = IERC20Upgradeable(pair.measure).balanceOf(user);
_captureClaimsForBalanceDrips(pair.source, pair.measure, user, measureBalance, dripTokens);
}
}
function _captureClaimsForBalanceDrips(
address source,
address measure,
address user,
uint256 userMeasureBalance,
address[] memory dripTokens
) internal {
uint i;
for (i = 0; i < dripTokens.length; i++) {
address dripToken = dripTokens[i];
BalanceDrip.State storage state = balanceDrips[source].balanceDrips[measure][dripToken];
if (state.exchangeRateMantissa > 0) {
_captureClaimForBalanceDrip(state, source, measure, dripToken, user, userMeasureBalance);
}
}
}
function _captureClaimForBalanceDrip(
BalanceDrip.State storage dripState,
address source,
address measure,
address dripToken,
address user,
uint256 measureBalance
) internal {
uint256 newUserTokens = dripState.captureNewTokensForUser(
user,
measureBalance
);
if (newUserTokens > 0) {
_addDripBalance(dripToken, user, newUserTokens);
emit BalanceDripDripped(source, measure, dripToken, user, newUserTokens);
}
}
function balanceOfClaims(
address user,
address[] memory dripTokens
) public view returns (DripTokenBalance[] memory) {
DripTokenBalance[] memory balances = new DripTokenBalance[](dripTokens.length);
uint256 i;
for (i = 0; i < dripTokens.length; i++) {
balances[i] = DripTokenBalance({
dripToken: dripTokens[i],
balance: dripTokenBalances[dripTokens[i]][user]
});
}
return balances;
}
/// @notice Updates the given drips for a user and then claims the given drip tokens. This call will
/// poke all of the drips and update the claim balances for the given user.
/// @dev This function will be useful to check the *current* claim balances for a user.
/// Just need to run this as a constant function to see the latest balances.
/// in order to claim the values, this function needs to be run alongside a claimDrip function.
/// @param pairs The (source, measure) pairs of drips to update for the given user
/// @param user The user for whom to update and claim tokens
/// @param dripTokens The drip tokens whose entire balance will be claimed after the update.
/// @return The claimable balance of each of the passed drip tokens for the user. These are the post-update balances, and therefore the most accurate.
function updateDrips(
UpdatePair[] memory pairs,
address user,
address[] memory dripTokens
)
public returns (DripTokenBalance[] memory)
{
updateActiveBalanceDripsForPairs(pairs);
captureClaimsForBalanceDripsForPairs(pairs, user, dripTokens);
updateActiveVolumeDripsForPairs(pairs);
mintAndCaptureVolumeDripsForPairs(pairs, user, 0, dripTokens);
DripTokenBalance[] memory balances = balanceOfClaims(user, dripTokens);
return balances;
}
/// @notice Updates the given drips for a user and then claims the given drip tokens. This call will
/// poke all of the drips and update the claim balances for the given user.
/// @dev This function will be useful to check the *current* claim balances for a user.
/// Just need to run this as a constant function to see the latest balances.
/// in order to claim the values, this function needs to be run alongside a claimDrip function.
/// @param pairs The (source, measure) pairs of drips to update for the given user
/// @param user The user for whom to update and claim tokens
/// @param dripTokens The drip tokens whose entire balance will be claimed after the update.
/// @return The claimable balance of each of the passed drip tokens for the user. These are the post-update balances, and therefore the most accurate.
function updateAndClaimDrips(
UpdatePair[] calldata pairs,
address user,
address[] calldata dripTokens
)
external returns (DripTokenBalance[] memory)
{
DripTokenBalance[] memory balances = updateDrips(pairs, user, dripTokens);
claimDrips(user, dripTokens);
return balances;
}
function _activeBalanceDripTokens(address source, address measure) internal view returns (address[] memory) {
return balanceDrips[source].activeBalanceDrips[measure].addressArray();
}
function _activeVolumeDripTokens(address source, address measure) internal view returns (address[] memory) {
return volumeDrips[source].activeVolumeDrips[measure].addressArray();
}
function _activeReferralVolumeDripTokens(address source, address measure) internal view returns (address[] memory) {
return referralVolumeDrips[source].activeVolumeDrips[measure].addressArray();
}
/// @notice Updates the balance drips
/// @param source The Prize Pool of the balance drip
/// @param manager The BalanceDripManager whose drips should be updated
/// @param measure The measure token whose balance is changing
/// @param measureTotalSupply The last total supply of the measure tokens
/// @param currentTime The current
function _updateActiveBalanceDrips(
BalanceDripManager.State storage manager,
address source,
address measure,
uint256 measureTotalSupply,
uint256 currentTime
) internal {
address prevDripToken = manager.activeBalanceDrips[measure].end();
address currentDripToken = manager.activeBalanceDrips[measure].start();
while (currentDripToken != address(0) && currentDripToken != manager.activeBalanceDrips[measure].end()) {
BalanceDrip.State storage dripState = manager.balanceDrips[measure][currentDripToken];
uint256 limit = _availableDripTokenBalance(currentDripToken);
uint256 newTokens = dripState.drip(
measureTotalSupply,
currentTime,
limit
);
// if we've hit the limit, then kill it.
bool isDripComplete = newTokens == limit;
if (isDripComplete) {
_deactivateBalanceDrip(source, measure, currentDripToken, prevDripToken);
}
prevDripToken = currentDripToken;
currentDripToken = manager.activeBalanceDrips[measure].next(currentDripToken);
}
}
/// @notice Records a deposit for a volume drip
/// @param source The Prize Pool of the volume drip
/// @param manager The VolumeDripManager containing the drips that need to be iterated through.
/// @param isReferral Whether the passed manager contains referral volume drip
/// @param measure The token that was deposited
function _updateActiveVolumeDrips(
VolumeDripManager.State storage manager,
address source,
address measure,
bool isReferral
)
internal
{
address prevDripToken = manager.activeVolumeDrips[measure].end();
uint256 currentTime = _currentTime();
address currentDripToken = manager.activeVolumeDrips[measure].start();
while (currentDripToken != address(0) && currentDripToken != manager.activeVolumeDrips[measure].end()) {
VolumeDrip.State storage dripState = manager.volumeDrips[measure][currentDripToken];
uint256 limit = _availableDripTokenBalance(currentDripToken);
uint32 lastPeriod = dripState.periodCount;
uint256 newTokens = dripState.drip(
currentTime,
limit
);
if (lastPeriod != dripState.periodCount) {
emit VolumeDripPeriodEnded(
source,
measure,
currentDripToken,
isReferral,
lastPeriod,
dripState.periods[lastPeriod].totalSupply,
newTokens
);
emit VolumeDripPeriodStarted(
source,
measure,
currentDripToken,
isReferral,
dripState.periodCount,
dripState.periods[dripState.periodCount].dripAmount,
dripState.periods[dripState.periodCount].endTime
);
}
// if we've hit the limit, then kill it.
bool isDripComplete = newTokens == limit;
if (isDripComplete) {
_deactivateVolumeDrip(source, measure, currentDripToken, isReferral, prevDripToken);
}
prevDripToken = currentDripToken;
currentDripToken = manager.activeVolumeDrips[measure].next(currentDripToken);
}
}
function _addDripBalance(address dripToken, address user, uint256 amount) internal returns (uint256) {
uint256 amountAvailable = _availableDripTokenBalance(dripToken);
uint256 actualAmount = (amount > amountAvailable) ? amountAvailable : amount;
dripTokenTotalSupply[dripToken] = dripTokenTotalSupply[dripToken].add(actualAmount);
dripTokenBalances[dripToken][user] = dripTokenBalances[dripToken][user].add(actualAmount);
emit DripTokenDripped(dripToken, user, actualAmount);
return actualAmount;
}
function _availableDripTokenBalance(address dripToken) internal view returns (uint256) {
uint256 comptrollerBalance = IERC20Upgradeable(dripToken).balanceOf(address(this));
uint256 totalClaimable = dripTokenTotalSupply[dripToken];
return (totalClaimable < comptrollerBalance) ? comptrollerBalance.sub(totalClaimable) : 0;
}
/// @notice Called by a "source" (i.e. Prize Pool) when a user mints new "measure" tokens.
/// @param to The user who is minting the tokens
/// @param amount The amount of tokens they are minting
/// @param measure The measure token they are minting
/// @param referrer The user who referred the minting.
function beforeTokenMint(
address to,
uint256 amount,
address measure,
address referrer
)
external
override
{
address source = _msgSender();
uint256 balance = IERC20Upgradeable(measure).balanceOf(to);
uint256 totalSupply = IERC20Upgradeable(measure).totalSupply();
address[] memory balanceDripTokens = _activeBalanceDripTokens(source, measure);
_updateActiveBalanceDrips(
balanceDrips[source],
source,
measure,
totalSupply,
_currentTime()
);
_captureClaimsForBalanceDrips(source, measure, to, balance, balanceDripTokens);
address[] memory volumeDripTokens = _activeVolumeDripTokens(source, measure);
_updateActiveVolumeDrips(
volumeDrips[source],
source,
measure,
false
);
_mintAndCaptureForVolumeDrips(source, measure, to, amount, volumeDripTokens);
if (referrer != address(0)) {
address[] memory referralVolumeDripTokens = _activeReferralVolumeDripTokens(source, measure);
_updateActiveVolumeDrips(
referralVolumeDrips[source],
source,
measure,
true
);
_mintAndCaptureReferralVolumeDrips(source, measure, referrer, amount, referralVolumeDripTokens);
}
}
/// @notice Called by a "source" (i.e. Prize Pool) when tokens change hands or are burned
/// @param from The user who is sending the tokens
/// @param to The user who is receiving the tokens
/// @param measure The measure token they are burning
function beforeTokenTransfer(
address from,
address to,
uint256,
address measure
)
external
override
{
if (from == address(0)) {
// ignore minting
return;
}
address source = _msgSender();
uint256 totalSupply = IERC20Upgradeable(measure).totalSupply();
uint256 fromBalance = IERC20Upgradeable(measure).balanceOf(from);
address[] memory balanceDripTokens = _activeBalanceDripTokens(source, measure);
_updateActiveBalanceDrips(
balanceDrips[source],
source,
measure,
totalSupply,
_currentTime()
);
_captureClaimsForBalanceDrips(source, measure, from, fromBalance, balanceDripTokens);
if (to != address(0)) {
uint256 toBalance = IERC20Upgradeable(measure).balanceOf(to);
_captureClaimsForBalanceDrips(source, measure, to, toBalance, balanceDripTokens);
}
}
/// @notice returns the current time. Allows for override in testing.
/// @return The current time (block.timestamp)
function _currentTime() internal virtual view returns (uint256) {
return block.timestamp;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
library UInt256Array {
function remove(uint256[] storage self, uint256 index) internal {
require(index < self.length, "UInt256Array/unknown-index");
self[index] = self[self.length-1];
delete self[self.length-1];
self.pop();
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "../drip/BalanceDripManager.sol";
import "../drip/VolumeDripManager.sol";
contract ComptrollerStorage is OwnableUpgradeable {
mapping(address => VolumeDripManager.State) internal volumeDrips;
mapping(address => VolumeDripManager.State) internal referralVolumeDrips;
mapping(address => BalanceDripManager.State) internal balanceDrips;
mapping(address => uint256) internal dripTokenTotalSupply;
mapping(address => mapping(address => uint256)) internal dripTokenBalances;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "../utils/MappedSinglyLinkedList.sol";
import "./BalanceDrip.sol";
/// @title Manages the lifecycle of a set of Balance Drips.
library BalanceDripManager {
using SafeMathUpgradeable for uint256;
using MappedSinglyLinkedList for MappedSinglyLinkedList.Mapping;
using BalanceDrip for BalanceDrip.State;
struct State {
mapping(address => MappedSinglyLinkedList.Mapping) activeBalanceDrips;
mapping(address => mapping(address => BalanceDrip.State)) balanceDrips;
}
/// @notice Activates a drip by setting it's state and adding it to the active balance drips list.
/// @param self The BalanceDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
/// @param dripRatePerSecond The amount of the drip token to be dripped per second
function activateDrip(
State storage self,
address measure,
address dripToken,
uint256 dripRatePerSecond
)
internal
{
require(!self.activeBalanceDrips[measure].contains(dripToken), "BalanceDripManager/drip-active");
if (self.activeBalanceDrips[measure].count == 0) {
self.activeBalanceDrips[measure].initialize();
}
self.activeBalanceDrips[measure].addAddress(dripToken);
self.balanceDrips[measure][dripToken].resetTotalDripped();
self.balanceDrips[measure][dripToken].dripRatePerSecond = dripRatePerSecond;
}
/// @notice Deactivates an active balance drip. The balance drip is removed from the active balance drips list.
/// The drip rate for the balance drip will be set to zero to ensure it's "frozen".
/// @param measure The measure token
/// @param dripToken The drip token
/// @param prevDripToken The previous drip token previous in the list.
/// If no previous, then pass the SENTINEL address: 0x0000000000000000000000000000000000000001
/// @param currentTime The current time
function deactivateDrip(
State storage self,
address measure,
address dripToken,
address prevDripToken,
uint32 currentTime,
uint256 maxNewTokens
)
internal
{
self.activeBalanceDrips[measure].removeAddress(prevDripToken, dripToken);
self.balanceDrips[measure][dripToken].drip(IERC20Upgradeable(measure).totalSupply(), currentTime, maxNewTokens);
self.balanceDrips[measure][dripToken].dripRatePerSecond = 0;
}
/// @notice Gets a list of active balance drip tokens
/// @param self The BalanceDripManager state
/// @param measure The measure token
/// @return An array of Balance Drip token addresses
function getActiveBalanceDrips(State storage self, address measure) internal view returns (address[] memory) {
return self.activeBalanceDrips[measure].addressArray();
}
/// @notice Sets the drip rate for an active balance drip.
/// @param self The BalanceDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
/// @param dripRatePerSecond The amount to drip of the token each second
/// @param currentTime The current time.
function setDripRate(
State storage self,
address measure,
address dripToken,
uint256 dripRatePerSecond,
uint32 currentTime,
uint256 maxNewTokens
) internal {
require(self.activeBalanceDrips[measure].contains(dripToken), "BalanceDripManager/drip-not-active");
self.balanceDrips[measure][dripToken].drip(IERC20Upgradeable(measure).totalSupply(), currentTime, maxNewTokens);
self.balanceDrips[measure][dripToken].dripRatePerSecond = dripRatePerSecond;
}
/// @notice Returns whether or not a drip is active for the given measure, dripToken pair
/// @param self The BalanceDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
/// @return True if there is an active balance drip for the pair, false otherwise
function isDripActive(State storage self, address measure, address dripToken) internal view returns (bool) {
return self.activeBalanceDrips[measure].contains(dripToken);
}
/// @notice Returns the BalanceDrip.State for the given measure, dripToken pair
/// @param self The BalanceDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
/// @return The BalanceDrip.State for the pair
function getDrip(State storage self, address measure, address dripToken) internal view returns (BalanceDrip.State storage) {
return self.balanceDrips[measure][dripToken];
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/SafeCastUpgradeable.sol";
import "../utils/ExtendedSafeCast.sol";
import "@pooltogether/fixed-point/contracts/FixedPoint.sol";
/// @title Calculates a users share of a token faucet.
/// @notice The tokens are dripped at a "drip rate per second". This is the number of tokens that
/// are dripped each second to the entire supply of a "measure" token. A user's share of ownership
/// of the measure token corresponds to the share of the drip tokens per second.
library BalanceDrip {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
using ExtendedSafeCast for uint256;
struct UserState {
uint128 lastExchangeRateMantissa;
}
struct State {
uint256 dripRatePerSecond;
uint112 exchangeRateMantissa;
uint112 totalDripped;
uint32 timestamp;
mapping(address => UserState) userStates;
}
/// @notice Captures new tokens for a user
/// @dev This must be called before changes to the user's balance (i.e. before mint, transfer or burns)
/// @param self The balance drip state
/// @param user The user to capture tokens for
/// @param userMeasureBalance The current balance of the user's measure tokens
/// @return The number of new tokens
function captureNewTokensForUser(
State storage self,
address user,
uint256 userMeasureBalance
) internal returns (uint128) {
return _captureNewTokensForUser(
self,
user,
userMeasureBalance
);
}
function resetTotalDripped(State storage self) internal {
self.totalDripped = 0;
}
/// @notice Drips new tokens.
/// @dev Should be called immediately before a change to the measure token's total supply
/// @param self The balance drip state
/// @param measureTotalSupply The measure token's last total supply (prior to any change)
/// @param timestamp The current time
/// @param maxNewTokens Maximum new tokens that can be dripped
/// @return The number of new tokens dripped.
function drip(
State storage self,
uint256 measureTotalSupply,
uint256 timestamp,
uint256 maxNewTokens
) internal returns (uint256) {
// this should only run once per block.
if (self.timestamp == uint32(timestamp)) {
return 0;
}
uint256 lastTime = self.timestamp == 0 ? timestamp : self.timestamp;
uint256 newSeconds = timestamp.sub(lastTime);
uint112 exchangeRateMantissa = self.exchangeRateMantissa == 0 ? FixedPoint.SCALE.toUint112() : self.exchangeRateMantissa;
uint256 newTokens;
if (newSeconds > 0 && self.dripRatePerSecond > 0) {
newTokens = newSeconds.mul(self.dripRatePerSecond);
if (newTokens > maxNewTokens) {
newTokens = maxNewTokens;
}
uint256 indexDeltaMantissa = measureTotalSupply > 0 ? FixedPoint.calculateMantissa(newTokens, measureTotalSupply) : 0;
exchangeRateMantissa = uint256(exchangeRateMantissa).add(indexDeltaMantissa).toUint112();
}
self.exchangeRateMantissa = exchangeRateMantissa;
self.totalDripped = uint256(self.totalDripped).add(newTokens).toUint112();
self.timestamp = timestamp.toUint32();
return newTokens;
}
function _captureNewTokensForUser(
State storage self,
address user,
uint256 userMeasureBalance
) private returns (uint128) {
UserState storage userState = self.userStates[user];
uint256 lastExchangeRateMantissa = userState.lastExchangeRateMantissa;
if (lastExchangeRateMantissa == 0) {
// if the index is not intialized
lastExchangeRateMantissa = FixedPoint.SCALE.toUint112();
}
uint256 deltaExchangeRateMantissa = uint256(self.exchangeRateMantissa).sub(lastExchangeRateMantissa);
uint128 newTokens = FixedPoint.multiplyUintByMantissa(userMeasureBalance, deltaExchangeRateMantissa).toUint128();
self.userStates[user] = UserState({
lastExchangeRateMantissa: self.exchangeRateMantissa
});
return newTokens;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
library ExtendedSafeCast {
/**
* @dev Converts an unsigned uint256 into a unsigned uint112.
*
* Requirements:
*
* - input must be less than or equal to maxUint112.
*/
function toUint112(uint256 value) internal pure returns (uint112) {
require(value < 2**112, "SafeCast: value doesn't fit in an uint112");
return uint112(value);
}
/**
* @dev Converts an unsigned uint256 into a unsigned uint96.
*
* Requirements:
*
* - input must be less than or equal to maxUint96.
*/
function toUint96(uint256 value) internal pure returns (uint96) {
require(value < 2**96, "SafeCast: value doesn't fit in an uint96");
return uint96(value);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "../utils/MappedSinglyLinkedList.sol";
import "./VolumeDrip.sol";
/// @title Manages the active set of Volume Drips.
library VolumeDripManager {
using SafeMathUpgradeable for uint256;
using MappedSinglyLinkedList for MappedSinglyLinkedList.Mapping;
using VolumeDrip for VolumeDrip.State;
struct State {
mapping(address => MappedSinglyLinkedList.Mapping) activeVolumeDrips;
mapping(address => mapping(address => VolumeDrip.State)) volumeDrips;
}
/// @notice Activates a volume drip for the given (measure,dripToken) pair.
/// @param self The VolumeDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
/// @param periodSeconds The period of the volume drip in seconds
/// @param dripAmount The amount of tokens to drip each period
/// @param endTime The end time to set for the current period.
function activate(
State storage self,
address measure,
address dripToken,
uint32 periodSeconds,
uint112 dripAmount,
uint32 endTime
)
internal
returns (uint32)
{
require(!self.activeVolumeDrips[measure].contains(dripToken), "VolumeDripManager/drip-active");
if (self.activeVolumeDrips[measure].count == 0) {
self.activeVolumeDrips[measure].initialize();
}
self.activeVolumeDrips[measure].addAddress(dripToken);
self.volumeDrips[measure][dripToken].setNewPeriod(periodSeconds, dripAmount, endTime);
return self.volumeDrips[measure][dripToken].periodCount;
}
/// @notice Deactivates the volume drip for the given (measure, dripToken) pair.
/// @param self The VolumeDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
/// @param prevDripToken The active drip token previous to the passed on in the list.
function deactivate(
State storage self,
address measure,
address dripToken,
address prevDripToken
)
internal
{
self.activeVolumeDrips[measure].removeAddress(prevDripToken, dripToken);
}
/// @notice Gets a list of active balance drip tokens
/// @param self The BalanceDripManager state
/// @param measure The measure token
/// @return An array of Balance Drip token addresses
function getActiveVolumeDrips(State storage self, address measure) internal view returns (address[] memory) {
return self.activeVolumeDrips[measure].addressArray();
}
/// @notice Sets the parameters for the next period of an active volume drip
/// @param self The VolumeDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
/// @param periodSeconds The length in seconds to use for the next period
/// @param dripAmount The amount of tokens to be dripped in the next period
function set(State storage self, address measure, address dripToken, uint32 periodSeconds, uint112 dripAmount) internal {
require(self.activeVolumeDrips[measure].contains(dripToken), "VolumeDripManager/drip-not-active");
self.volumeDrips[measure][dripToken].setNextPeriod(periodSeconds, dripAmount);
}
/// @notice Returns whether or not an active volume drip exists for the given (measure, dripToken) pair
/// @param self The VolumeDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
function isActive(State storage self, address measure, address dripToken) internal view returns (bool) {
return self.activeVolumeDrips[measure].contains(dripToken);
}
/// @notice Returns the VolumeDrip.State for the given (measure, dripToken) pair.
/// @param self The VolumeDripManager state
/// @param measure The measure token
/// @param dripToken The drip token
function getDrip(State storage self, address measure, address dripToken) internal view returns (VolumeDrip.State storage) {
return self.volumeDrips[measure][dripToken];
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/SafeCastUpgradeable.sol";
import "@pooltogether/fixed-point/contracts/FixedPoint.sol";
import "../utils/ExtendedSafeCast.sol";
library VolumeDrip {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
using ExtendedSafeCast for uint256;
struct Deposit {
uint112 balance;
uint32 period;
}
struct Period {
uint112 totalSupply;
uint112 dripAmount;
uint32 endTime;
}
struct State {
mapping(address => Deposit) deposits;
mapping(uint32 => Period) periods;
uint32 nextPeriodSeconds;
uint112 nextDripAmount;
uint112 __gap;
uint112 totalDripped;
uint32 periodCount;
}
function setNewPeriod(
State storage self,
uint32 _periodSeconds,
uint112 dripAmount,
uint32 endTime
)
internal
minPeriod(_periodSeconds)
{
self.nextPeriodSeconds = _periodSeconds;
self.nextDripAmount = dripAmount;
self.totalDripped = 0;
self.periodCount = uint256(self.periodCount).add(1).toUint16();
self.periods[self.periodCount] = Period({
totalSupply: 0,
dripAmount: dripAmount,
endTime: endTime
});
}
function setNextPeriod(
State storage self,
uint32 _periodSeconds,
uint112 dripAmount
)
internal
minPeriod(_periodSeconds)
{
self.nextPeriodSeconds = _periodSeconds;
self.nextDripAmount = dripAmount;
}
function drip(
State storage self,
uint256 currentTime,
uint256 maxNewTokens
)
internal
returns (uint256)
{
if (_isPeriodOver(self, currentTime)) {
return _completePeriod(self, currentTime, maxNewTokens);
}
return 0;
}
function mint(
State storage self,
address user,
uint256 amount
)
internal
returns (uint256)
{
if (self.periodCount == 0) {
return 0;
}
uint256 accrued = _lastBalanceAccruedAmount(self, self.deposits[user].period, self.deposits[user].balance);
uint32 currentPeriod = self.periodCount;
if (accrued > 0) {
self.deposits[user] = Deposit({
balance: amount.toUint112(),
period: currentPeriod
});
} else {
self.deposits[user] = Deposit({
balance: uint256(self.deposits[user].balance).add(amount).toUint112(),
period: currentPeriod
});
}
self.periods[currentPeriod].totalSupply = uint256(self.periods[currentPeriod].totalSupply).add(amount).toUint112();
return accrued;
}
function currentPeriod(State storage self) internal view returns (Period memory) {
return self.periods[self.periodCount];
}
function _isPeriodOver(State storage self, uint256 currentTime) private view returns (bool) {
return currentTime >= self.periods[self.periodCount].endTime;
}
function _completePeriod(
State storage self,
uint256 currentTime,
uint256 maxNewTokens
) private onlyPeriodOver(self, currentTime) returns (uint256) {
// calculate the actual drip amount
uint112 dripAmount;
// If no one deposited, then don't drip anything
if (self.periods[self.periodCount].totalSupply > 0) {
dripAmount = self.periods[self.periodCount].dripAmount;
}
// if the drip amount is not valid, it has to be updated.
if (dripAmount > maxNewTokens) {
dripAmount = maxNewTokens.toUint112();
self.periods[self.periodCount].dripAmount = dripAmount;
}
// if we are completing the period far into the future, then we'll have skipped a lot of periods.
// Here we set the end time so that it's the next period from *now*
uint256 lastEndTime = self.periods[self.periodCount].endTime;
uint256 numberOfPeriods = currentTime.sub(lastEndTime).div(self.nextPeriodSeconds).add(1);
uint256 endTime = lastEndTime.add(numberOfPeriods.mul(self.nextPeriodSeconds));
self.totalDripped = uint256(self.totalDripped).add(dripAmount).toUint112();
self.periodCount = uint256(self.periodCount).add(1).toUint16();
self.periods[self.periodCount] = Period({
totalSupply: 0,
dripAmount: self.nextDripAmount,
endTime: endTime.toUint32()
});
return dripAmount;
}
function _lastBalanceAccruedAmount(
State storage self,
uint32 depositPeriod,
uint128 balance
)
private view
returns (uint256)
{
uint256 accrued;
if (depositPeriod < self.periodCount && self.periods[depositPeriod].totalSupply > 0) {
uint256 fractionMantissa = FixedPoint.calculateMantissa(balance, self.periods[depositPeriod].totalSupply);
accrued = FixedPoint.multiplyUintByMantissa(self.periods[depositPeriod].dripAmount, fractionMantissa);
}
return accrued;
}
modifier onlyPeriodNotOver(State storage self, uint256 _currentTime) {
require(!_isPeriodOver(self, _currentTime), "VolumeDrip/period-over");
_;
}
modifier onlyPeriodOver(State storage self, uint256 _currentTime) {
require(_isPeriodOver(self, _currentTime), "VolumeDrip/period-not-over");
_;
}
modifier minPeriod(uint256 _periodSeconds) {
require(_periodSeconds > 0, "VolumeDrip/period-gt-zero");
_;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
interface DaiInterface is IERC20Upgradeable {
// --- Approve by signature ---
function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external;
function transferFrom(address src, address dst, uint wad) external override returns (bool);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "../external/maker/DaiInterface.sol";
import "../prize-pool/PrizePoolInterface.sol";
/// @title Allows users to approve and deposit dai into a prize pool in a single transaction.
contract PermitAndDepositDai is OwnableUpgradeable {
using SafeERC20Upgradeable for DaiInterface;
/// @notice Permits this contract to spend on a users behalf, and deposits into the prize pool.
/// @dev The Dai permit params match the Dai#permit function, but it expects the `spender` to be
/// the address of this contract.
/// @param holder The address spending the tokens
/// @param nonce The nonce of the tx. Should be retrieved from the Dai token
/// @param expiry The timestamp at which the sig expires
/// @param allowed If true, then the spender is approving holder the max allowance. False makes the allowance zero.
/// @param v The `v` portion of the signature.
/// @param r The `r` portion of the signature.
/// @param s The `s` portion of the signature.
/// @param prizePool The prize pool to deposit into
/// @param to The address that will receive the controlled tokens
/// @param amount The amount to deposit
/// @param controlledToken The type of token to be minted in exchange (i.e. tickets or sponsorship)
/// @param referrer The address that referred the deposit
function permitAndDepositTo(
// --- Approve by signature ---
address dai, address holder, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s,
address prizePool, address to, uint256 amount, address controlledToken, address referrer
) external {
require(msg.sender == holder, "PermitAndDepositDai/only-signer");
DaiInterface(dai).permit(holder, address(this), nonce, expiry, allowed, v, r, s);
_depositTo(dai, holder, prizePool, to, amount, controlledToken, referrer);
}
/// @notice Deposits into a Prize Pool from the sender. Tokens will be transferred from the sender
/// then deposited into the Pool on the sender's behalf. This can be called after permitAndDepositTo is called,
/// as this contract will have full approval for a user.
/// @param prizePool The prize pool to deposit into
/// @param to The address that will receive the controlled tokens
/// @param amount The amount to deposit
/// @param controlledToken The type of token to be minted in exchange (i.e. tickets or sponsorship)
/// @param referrer The address that referred the deposit
function depositTo(
address dai,
address prizePool,
address to,
uint256 amount,
address controlledToken,
address referrer
) external {
_depositTo(dai, msg.sender, prizePool, to, amount, controlledToken, referrer);
}
function _depositTo(
address dai,
address holder,
address prizePool,
address to,
uint256 amount,
address controlledToken,
address referrer
) internal {
DaiInterface(dai).safeTransferFrom(holder, address(this), amount);
DaiInterface(dai).approve(address(prizePool), amount);
PrizePoolInterface(prizePool).depositTo(to, amount, controlledToken, referrer);
}
}
pragma solidity ^0.6.12;
import "./PeriodicPrizeStrategyListenerInterface.sol";
import "./PeriodicPrizeStrategyListenerLibrary.sol";
import "../Constants.sol";
abstract contract PeriodicPrizeStrategyListener is PeriodicPrizeStrategyListenerInterface {
function supportsInterface(bytes4 interfaceId) external override view returns (bool) {
return (
interfaceId == Constants.ERC165_INTERFACE_ID_ERC165 ||
interfaceId == PeriodicPrizeStrategyListenerLibrary.ERC165_INTERFACE_ID_PERIODIC_PRIZE_STRATEGY_LISTENER
);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "../PeriodicPrizeStrategy.sol";
/* solium-disable security/no-block-members */
contract SingleRandomWinner is PeriodicPrizeStrategy {
event NoWinner();
function _distribute(uint256 randomNumber) internal override {
uint256 prize = prizePool.captureAwardBalance();
address winner = ticket.draw(randomNumber);
if (winner != address(0)) {
_awardTickets(winner, prize);
_awardAllExternalTokens(winner);
} else {
emit NoWinner();
}
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "./SingleRandomWinner.sol";
import "../../external/openzeppelin/ProxyFactory.sol";
contract SingleRandomWinnerProxyFactory is ProxyFactory {
SingleRandomWinner public instance;
constructor () public {
instance = new SingleRandomWinner();
}
function create() external returns (SingleRandomWinner) {
return SingleRandomWinner(deployMinimal(address(instance), ""));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "./RegistryInterface.sol";
/// @title Interface that allows a user to draw an address using an index
contract Registry is OwnableUpgradeable, RegistryInterface {
address private pointer;
event Registered(address indexed pointer);
constructor () public {
__Ownable_init();
}
function register(address _pointer) external onlyOwner {
pointer = _pointer;
emit Registered(pointer);
}
function lookup() external override view returns (address) {
return pointer;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "./ReserveInterface.sol";
import "../prize-pool/PrizePoolInterface.sol";
/// @title Interface that allows a user to draw an address using an index
contract Reserve is OwnableUpgradeable, ReserveInterface {
event ReserveRateMantissaSet(uint256 rateMantissa);
uint256 public rateMantissa;
constructor () public {
__Ownable_init();
}
function setRateMantissa(
uint256 _rateMantissa
)
external
onlyOwner
{
rateMantissa = _rateMantissa;
emit ReserveRateMantissaSet(rateMantissa);
}
function withdrawReserve(address prizePool, address to) external onlyOwner returns (uint256) {
return PrizePoolInterface(prizePool).withdrawReserve(to);
}
function reserveRateMantissa(address) external view override returns (uint256) {
return rateMantissa;
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../drip/BalanceDrip.sol";
contract BalanceDripExposed {
using BalanceDrip for BalanceDrip.State;
event DrippedTotalSupply(
uint256 newTokens
);
event Dripped(
address indexed user,
uint256 newTokens
);
BalanceDrip.State internal dripState;
function setDripRate(
uint256 dripRatePerSecond
) external {
dripState.dripRatePerSecond = dripRatePerSecond;
}
function drip(
uint256 measureTotalSupply,
uint256 currentTime,
uint256 maxNewTokens
) external returns (uint256) {
uint256 newTokens = dripState.drip(
measureTotalSupply,
currentTime,
maxNewTokens
);
emit DrippedTotalSupply(newTokens);
return newTokens;
}
function captureNewTokensForUser(
address user,
uint256 userMeasureBalance
) external returns (uint128) {
uint128 newTokens = dripState.captureNewTokensForUser(
user,
userMeasureBalance
);
emit Dripped(user, newTokens);
return newTokens;
}
function dripTwice(
uint256 measureTotalSupply,
uint256 currentTime,
uint256 maxNewTokens
) external returns (uint256) {
uint256 newTokens = dripState.drip(
measureTotalSupply,
currentTime,
maxNewTokens
);
newTokens = newTokens + dripState.drip(
measureTotalSupply,
currentTime,
maxNewTokens
);
emit DrippedTotalSupply(newTokens);
return newTokens;
}
function exchangeRateMantissa() external view returns (uint256) {
return dripState.exchangeRateMantissa;
}
function totalDripped() external view returns (uint256) {
return dripState.totalDripped;
}
function resetTotalDripped() external {
dripState.resetTotalDripped();
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../drip/BalanceDripManager.sol";
contract BalanceDripManagerExposed {
using BalanceDripManager for BalanceDripManager.State;
BalanceDripManager.State dripManager;
function activateDrip(address measure, address dripToken, uint256 dripRatePerSecond) external {
dripManager.activateDrip(measure, dripToken, dripRatePerSecond);
}
function deactivateDrip(address measure, address prevDripToken, address dripToken, uint32 currentTime, uint256 maxNewTokens) external {
dripManager.deactivateDrip(measure, prevDripToken, dripToken, currentTime, maxNewTokens);
}
function isDripActive(address measure, address dripToken) external view returns (bool) {
return dripManager.isDripActive(measure, dripToken);
}
function setDripRate(address measure, address dripToken, uint256 dripRatePerSecond, uint32 currentTime, uint256 maxNewTokens) external {
dripManager.setDripRate(measure, dripToken, dripRatePerSecond, currentTime, maxNewTokens);
}
function getActiveBalanceDrips(address measure) external view returns (address[] memory) {
return dripManager.getActiveBalanceDrips(measure);
}
function getDrip(
address measure,
address dripToken
)
external
view
returns (
uint256 dripRatePerSecond,
uint128 exchangeRateMantissa,
uint32 timestamp
)
{
BalanceDrip.State storage dripState = dripManager.getDrip(measure, dripToken);
dripRatePerSecond = dripState.dripRatePerSecond;
exchangeRateMantissa = dripState.exchangeRateMantissa;
timestamp = dripState.timestamp;
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../prize-pool/compound/CompoundPrizePool.sol";
/* solium-disable security/no-block-members */
contract CompoundPrizePoolHarness is CompoundPrizePool {
uint256 public currentTime;
function setCurrentTime(uint256 _currentTime) external {
currentTime = _currentTime;
}
function setTimelockBalance(uint256 _timelockBalance) external {
timelockTotalSupply = _timelockBalance;
}
function _currentTime() internal override view returns (uint256) {
return currentTime;
}
function supply(uint256 mintAmount) external {
_supply(mintAmount);
}
function redeem(uint256 redeemAmount) external returns (uint256) {
return _redeem(redeemAmount);
}
}
pragma solidity >=0.6.0 <0.7.0;
import "./CompoundPrizePoolHarness.sol";
import "../external/openzeppelin/ProxyFactory.sol";
/// @title Compound Prize Pool Proxy Factory
/// @notice Minimal proxy pattern for creating new Compound Prize Pools
contract CompoundPrizePoolHarnessProxyFactory is ProxyFactory {
/// @notice Contract template for deploying proxied Prize Pools
CompoundPrizePoolHarness public instance;
/// @notice Initializes the Factory with an instance of the Compound Prize Pool
constructor () public {
instance = new CompoundPrizePoolHarness();
}
/// @notice Creates a new Compound Prize Pool as a proxy of the template instance
/// @return A reference to the new proxied Compound Prize Pool
function create() external returns (CompoundPrizePoolHarness) {
return CompoundPrizePoolHarness(deployMinimal(address(instance), ""));
}
}
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "../comptroller/Comptroller.sol";
/* solium-disable security/no-block-members */
contract ComptrollerHarness is Comptroller {
uint256 internal time;
function setCurrentTime(uint256 _time) external {
time = _time;
}
function _currentTime() internal override view returns (uint256) {
return time;
}
}
/**
Copyright 2019 PoolTogether LLC
This file is part of PoolTogether.
PoolTogether is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation under version 3 of the License.
PoolTogether is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with PoolTogether. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@pooltogether/fixed-point/contracts/FixedPoint.sol";
import "./ERC20Mintable.sol";
contract CTokenMock is ERC20Upgradeable {
mapping(address => uint256) internal ownerTokenAmounts;
ERC20Mintable public underlying;
uint256 internal __supplyRatePerBlock;
constructor (
ERC20Mintable _token,
uint256 _supplyRatePerBlock
) public {
require(address(_token) != address(0), "token is not defined");
underlying = _token;
__supplyRatePerBlock = _supplyRatePerBlock;
}
function mint(uint256 amount) external returns (uint) {
uint256 newCTokens;
if (totalSupply() == 0) {
newCTokens = amount;
} else {
// they need to hold the same assets as tokens.
// Need to calculate the current exchange rate
uint256 fractionOfCredit = FixedPoint.calculateMantissa(amount, underlying.balanceOf(address(this)));
newCTokens = FixedPoint.multiplyUintByMantissa(totalSupply(), fractionOfCredit);
}
_mint(msg.sender, newCTokens);
require(underlying.transferFrom(msg.sender, address(this), amount), "could not transfer tokens");
return 0;
}
function getCash() external view returns (uint) {
return underlying.balanceOf(address(this));
}
function redeemUnderlying(uint256 requestedAmount) external returns (uint) {
uint256 cTokens = cTokenValueOf(requestedAmount);
_burn(msg.sender, cTokens);
require(underlying.transfer(msg.sender, requestedAmount), "could not transfer tokens");
}
function accrue() external {
uint256 newTokens = (underlying.balanceOf(address(this)) * 120) / 100;
underlying.mint(address(this), newTokens);
}
function accrueCustom(uint256 amount) external {
underlying.mint(address(this), amount);
}
function burn(uint256 amount) external {
underlying.burn(address(this), amount);
}
function cTokenValueOf(uint256 tokens) public view returns (uint256) {
return FixedPoint.divideUintByMantissa(tokens, exchangeRateCurrent());
}
function balanceOfUnderlying(address account) public view returns (uint) {
return FixedPoint.multiplyUintByMantissa(balanceOf(account), exchangeRateCurrent());
}
function exchangeRateCurrent() public view returns (uint256) {
if (totalSupply() == 0) {
return FixedPoint.SCALE;
} else {
return FixedPoint.calculateMantissa(underlying.balanceOf(address(this)), totalSupply());
}
}
function supplyRatePerBlock() external view returns (uint) {
return __supplyRatePerBlock;
}
function setSupplyRateMantissa(uint256 _supplyRatePerBlock) external {
__supplyRatePerBlock = _supplyRatePerBlock;
}
}
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
/**
* @dev Extension of {ERC20} that adds a set of accounts with the {MinterRole},
* which have permission to mint (create) new tokens as they see fit.
*
* At construction, the deployer of the contract is the only minter.
*/
contract ERC20Mintable is ERC20Upgradeable {
constructor(string memory _name, string memory _symbol) public {
__ERC20_init(_name, _symbol);
}
/**
* @dev See {ERC20-_mint}.
*
* Requirements:
*
* - the caller must have the {MinterRole}.
*/
function mint(address account, uint256 amount) public returns (bool) {
_mint(account, amount);
return true;
}
function burn(address account, uint256 amount) public returns (bool) {
_burn(account, amount);
return true;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "../external/maker/DaiInterface.sol";
contract Dai is DaiInterface {
using SafeMathUpgradeable for uint256;
using AddressUpgradeable for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (uint256 chainId_) public {
string memory version = "1";
_name = "Dai Stablecoin";
_symbol = "DAI";
_decimals = 18;
DOMAIN_SEPARATOR = keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(_name)),
keccak256(bytes(version)),
chainId_,
address(this)
)
);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
mapping (address => uint) public nonces;
// --- EIP712 niceties ---
bytes32 public DOMAIN_SEPARATOR;
// bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address holder,address spender,uint256 nonce,uint256 expiry,bool allowed)");
bytes32 public constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;
// --- Approve by signature ---
function permit(
address holder, address spender, uint256 nonce, uint256 expiry,
bool allowed, uint8 v, bytes32 r, bytes32 s) external override
{
bytes32 digest = keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR,
keccak256(
abi.encode(
PERMIT_TYPEHASH,
holder,
spender,
nonce,
expiry,
allowed
)
)
)
);
require(holder != address(0), "Dai/invalid-address-0");
require(holder == ecrecover(digest, v, r, s), "Dai/invalid-permit");
require(expiry == 0 || now <= expiry, "Dai/permit-expired");
require(nonce == nonces[holder]++, "Dai/invalid-nonce");
uint wad = allowed ? uint(-1) : 0;
_allowances[holder][spender] = wad;
emit Approval(holder, spender, wad);
}
function mint(address to, uint256 amount) external {
_mint(to, amount);
}
}
pragma solidity >=0.6.0 <0.7.0;
/* solium-disable security/no-inline-assembly */
contract DoppelgangerWithExec {
struct MockCall {
bool initialized;
bool reverts;
bytes returnValue;
}
mapping(bytes32 => MockCall) mockConfig;
fallback() external payable {
MockCall storage mockCall = __internal__getMockCall();
if (mockCall.reverts == true) {
__internal__mockRevert();
return;
}
__internal__mockReturn(mockCall.returnValue);
}
function __waffle__mockReverts(bytes memory data) public {
mockConfig[keccak256(data)] = MockCall({
initialized: true,
reverts: true,
returnValue: ""
});
}
function __waffle__mockReturns(bytes memory data, bytes memory value) public {
mockConfig[keccak256(data)] = MockCall({
initialized: true,
reverts: false,
returnValue: value
});
}
function __waffle__call(address target, bytes calldata data) external returns (bytes memory) {
(bool succeeded, bytes memory returnValue) = target.call(data);
require(succeeded, string(returnValue));
return returnValue;
}
function __waffle__staticcall(address target, bytes calldata data) external view returns (bytes memory) {
(bool succeeded, bytes memory returnValue) = target.staticcall(data);
require(succeeded, string(returnValue));
return returnValue;
}
function __internal__getMockCall() view private returns (MockCall storage mockCall) {
mockCall = mockConfig[keccak256(msg.data)];
if (mockCall.initialized == true) {
// Mock method with specified arguments
return mockCall;
}
mockCall = mockConfig[keccak256(abi.encodePacked(msg.sig))];
if (mockCall.initialized == true) {
// Mock method with any arguments
return mockCall;
}
revert("Mock on the method is not initialized");
}
function __internal__mockReturn(bytes memory ret) pure private {
assembly {
return (add(ret, 0x20), mload(ret))
}
}
function __internal__mockRevert() pure private {
revert("Mock revert");
}
}
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/introspection/IERC1820ImplementerUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC777/IERC777RecipientUpgradeable.sol";
import "../Constants.sol";
contract ERC1820ImplementerMock is IERC1820ImplementerUpgradeable, IERC777RecipientUpgradeable {
constructor () public {
Constants.REGISTRY.setInterfaceImplementer(address(this), Constants.TOKENS_RECIPIENT_INTERFACE_HASH, address(this));
}
function canImplementInterfaceForAddress(bytes32, address) external view virtual override returns(bytes32) {
return Constants.ACCEPT_MAGIC;
}
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external override {
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface for an ERC1820 implementer, as defined in the
* https://eips.ethereum.org/EIPS/eip-1820#interface-implementation-erc1820implementerinterface[EIP].
* Used by contracts that will be registered as implementers in the
* {IERC1820Registry}.
*/
interface IERC1820ImplementerUpgradeable {
/**
* @dev Returns a special value (`ERC1820_ACCEPT_MAGIC`) if this contract
* implements `interfaceHash` for `account`.
*
* See {IERC1820Registry-setInterfaceImplementer}.
*/
function canImplementInterfaceForAddress(bytes32 interfaceHash, address account) external view returns (bytes32);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the ERC777TokensRecipient standard as defined in the EIP.
*
* Accounts can be notified of {IERC777} tokens being sent to them by having a
* contract implement this interface (contract holders can be their own
* implementer) and registering it on the
* https://eips.ethereum.org/EIPS/eip-1820[ERC1820 global registry].
*
* See {IERC1820Registry} and {ERC1820Implementer}.
*/
interface IERC777RecipientUpgradeable {
/**
* @dev Called by an {IERC777} token contract whenever tokens are being
* moved or created into a registered account (`to`). The type of operation
* is conveyed by `from` being the zero address or not.
*
* This call occurs _after_ the token contract's state is updated, so
* {IERC777-balanceOf}, etc., can be used to query the post-operation state.
*
* This function may revert to prevent the operation from being executed.
*/
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external;
}
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
/**
* @dev Extension of {ERC721} for Minting/Burning
*/
contract ERC721Mintable is ERC721Upgradeable {
constructor () public {
__ERC721_init("ERC 721", "NFT");
}
/**
* @dev See {ERC721-_mint}.
*/
function mint(address to, uint256 tokenId) public {
_mint(to, tokenId);
}
/**
* @dev See {ERC721-_burn}.
*/
function burn(uint256 tokenId) public {
_burn(tokenId);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../../GSN/ContextUpgradeable.sol";
import "./IERC721Upgradeable.sol";
import "./IERC721MetadataUpgradeable.sol";
import "./IERC721EnumerableUpgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "../../introspection/ERC165Upgradeable.sol";
import "../../math/SafeMathUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/EnumerableSetUpgradeable.sol";
import "../../utils/EnumerableMapUpgradeable.sol";
import "../../utils/StringsUpgradeable.sol";
import "../../proxy/Initializable.sol";
/**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/
contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable, IERC721EnumerableUpgradeable {
using SafeMathUpgradeable for uint256;
using AddressUpgradeable for address;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet;
using EnumerableMapUpgradeable for EnumerableMapUpgradeable.UintToAddressMap;
using StringsUpgradeable for uint256;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from holder address to their (enumerable) set of owned tokens
mapping (address => EnumerableSetUpgradeable.UintSet) private _holderTokens;
// Enumerable mapping from token ids to their owners
EnumerableMapUpgradeable.UintToAddressMap private _tokenOwners;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping (uint256 => string) private _tokenURIs;
// Base URI
string private _baseURI;
/*
* bytes4(keccak256('balanceOf(address)')) == 0x70a08231
* bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
* bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
* bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
* bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
*
* => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
* 0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
*/
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
/*
* bytes4(keccak256('name()')) == 0x06fdde03
* bytes4(keccak256('symbol()')) == 0x95d89b41
* bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
*
* => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
*/
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
/*
* bytes4(keccak256('totalSupply()')) == 0x18160ddd
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
* bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
*
* => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
*/
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
function __ERC721_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {
_name = name_;
_symbol = symbol_;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721);
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _holderTokens[owner].length();
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
// If there is no base URI, return the token URI.
if (bytes(_baseURI).length == 0) {
return _tokenURI;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(_baseURI, _tokenURI));
}
// If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
return string(abi.encodePacked(_baseURI, tokenId.toString()));
}
/**
* @dev Returns the base URI set via {_setBaseURI}. This will be
* automatically added as a prefix in {tokenURI} to each token's URI, or
* to the token ID if no specific URI is set for that token ID.
*/
function baseURI() public view returns (string memory) {
return _baseURI;
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
return _holderTokens[owner].at(index);
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
// _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
return _tokenOwners.length();
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
(uint256 tokenId, ) = _tokenOwners.at(index);
return tokenId;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view returns (bool) {
return _tokenOwners.contains(tokenId);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
d*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
_holderTokens[owner].remove(tokenId);
_tokenOwners.remove(tokenId);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_holderTokens[from].remove(tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(from, to, tokenId);
}
/**
* @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
/**
* @dev Internal function to set the base URI for all token IDs. It is
* automatically added as a prefix to the value returned in {tokenURI},
* or to the token ID if {tokenURI} is empty.
*/
function _setBaseURI(string memory baseURI_) internal virtual {
_baseURI = baseURI_;
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes memory returndata = to.functionCall(abi.encodeWithSelector(
IERC721ReceiverUpgradeable(to).onERC721Received.selector,
_msgSender(),
from,
tokenId,
_data
), "ERC721: transfer to non ERC721Receiver implementer");
bytes4 retval = abi.decode(returndata, (bytes4));
return (retval == _ERC721_RECEIVED);
}
function _approve(address to, uint256 tokenId) private {
_tokenApprovals[tokenId] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
uint256[41] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.8.0;
import "./IERC721Upgradeable.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.8.0;
import "./IERC721Upgradeable.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721EnumerableUpgradeable is IERC721Upgradeable {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev 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);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721ReceiverUpgradeable {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "./IERC165Upgradeable.sol";
import "../proxy/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts may inherit from this and call {_registerInterface} to declare
* their support of an interface.
*/
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* @dev Mapping of interface ids to whether or not it's supported.
*/
mapping(bytes4 => bool) private _supportedInterfaces;
function __ERC165_init() internal initializer {
__ERC165_init_unchained();
}
function __ERC165_init_unchained() internal initializer {
// Derived contracts need only register support for their own interfaces,
// we register support for ERC165 itself here
_registerInterface(_INTERFACE_ID_ERC165);
}
/**
* @dev See {IERC165-supportsInterface}.
*
* Time complexity O(1), guaranteed to always use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
return _supportedInterfaces[interfaceId];
}
/**
* @dev Registers the contract as an implementer of the interface defined by
* `interfaceId`. Support of the actual ERC165 interface is automatic and
* registering its interface id is not required.
*
* See {IERC165-supportsInterface}.
*
* Requirements:
*
* - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
*/
function _registerInterface(bytes4 interfaceId) internal virtual {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*/
library EnumerableSetUpgradeable {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Library for managing an enumerable variant of Solidity's
* https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
* type.
*
* Maps have the following properties:
*
* - Entries are added, removed, and checked for existence in constant time
* (O(1)).
* - Entries are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableMap for EnumerableMap.UintToAddressMap;
*
* // Declare a set state variable
* EnumerableMap.UintToAddressMap private myMap;
* }
* ```
*
* As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
* supported.
*/
library EnumerableMapUpgradeable {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Map type with
// bytes32 keys and values.
// The Map implementation uses private functions, and user-facing
// implementations (such as Uint256ToAddressMap) are just wrappers around
// the underlying Map.
// This means that we can only create new EnumerableMaps for types that fit
// in bytes32.
struct MapEntry {
bytes32 _key;
bytes32 _value;
}
struct Map {
// Storage of map keys and values
MapEntry[] _entries;
// Position of the entry defined by a key in the `entries` array, plus 1
// because index 0 means a key is not in the map.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
// We read and store the key's index to prevent multiple reads from the same storage slot
uint256 keyIndex = map._indexes[key];
if (keyIndex == 0) { // Equivalent to !contains(map, key)
map._entries.push(MapEntry({ _key: key, _value: value }));
// The entry is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
map._indexes[key] = map._entries.length;
return true;
} else {
map._entries[keyIndex - 1]._value = value;
return false;
}
}
/**
* @dev Removes a key-value pair from a map. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function _remove(Map storage map, bytes32 key) private returns (bool) {
// We read and store the key's index to prevent multiple reads from the same storage slot
uint256 keyIndex = map._indexes[key];
if (keyIndex != 0) { // Equivalent to contains(map, key)
// To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
// in the array, and then remove the last entry (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = keyIndex - 1;
uint256 lastIndex = map._entries.length - 1;
// When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
MapEntry storage lastEntry = map._entries[lastIndex];
// Move the last entry to the index where the entry to delete is
map._entries[toDeleteIndex] = lastEntry;
// Update the index for the moved entry
map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved entry was stored
map._entries.pop();
// Delete the index for the deleted slot
delete map._indexes[key];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function _contains(Map storage map, bytes32 key) private view returns (bool) {
return map._indexes[key] != 0;
}
/**
* @dev Returns the number of key-value pairs in the map. O(1).
*/
function _length(Map storage map) private view returns (uint256) {
return map._entries.length;
}
/**
* @dev Returns the key-value pair stored at position `index` in the map. O(1).
*
* Note that there are no guarantees on the ordering of entries inside the
* array, and it may change when more entries are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
require(map._entries.length > index, "EnumerableMap: index out of bounds");
MapEntry storage entry = map._entries[index];
return (entry._key, entry._value);
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function _get(Map storage map, bytes32 key) private view returns (bytes32) {
return _get(map, key, "EnumerableMap: nonexistent key");
}
/**
* @dev Same as {_get}, with a custom error message when `key` is not in the map.
*/
function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
return map._entries[keyIndex - 1]._value; // All indexes are 1-based
}
// UintToAddressMap
struct UintToAddressMap {
Map _inner;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
return _set(map._inner, bytes32(key), bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
return _remove(map._inner, bytes32(key));
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
return _contains(map._inner, bytes32(key));
}
/**
* @dev Returns the number of elements in the map. O(1).
*/
function length(UintToAddressMap storage map) internal view returns (uint256) {
return _length(map._inner);
}
/**
* @dev Returns the element stored at position `index` in the set. O(1).
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
(bytes32 key, bytes32 value) = _at(map._inner, index);
return (uint256(key), address(uint256(value)));
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
return address(uint256(_get(map._inner, bytes32(key))));
}
/**
* @dev Same as {get}, with a custom error message when `key` is not in the map.
*/
function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
return address(uint256(_get(map._inner, bytes32(key), errorMessage)));
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev String operations.
*/
library StringsUpgradeable {
/**
* @dev Converts a `uint256` to its ASCII `string` representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = byte(uint8(48 + temp % 10));
temp /= 10;
}
return string(buffer);
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../utils/ExtendedSafeCast.sol";
contract ExtendedSafeCastExposed {
function toUint112(uint256 value) external pure returns (uint112) {
return ExtendedSafeCast.toUint112(value);
}
function toUint96(uint256 value) external pure returns (uint96) {
return ExtendedSafeCast.toUint96(value);
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../utils/MappedSinglyLinkedList.sol";
contract MappedSinglyLinkedListExposed {
using MappedSinglyLinkedList for MappedSinglyLinkedList.Mapping;
MappedSinglyLinkedList.Mapping list;
function initialize() external {
list.initialize();
}
function addressArray() external view returns (address[] memory) {
return list.addressArray();
}
function addAddresses(address[] calldata addresses) external {
list.addAddresses(addresses);
}
function addAddress(address newAddress) external {
list.addAddress(newAddress);
}
function removeAddress(address prevAddress, address addr) external {
list.removeAddress(prevAddress, addr);
}
function contains(address addr) external view returns (bool) {
return list.contains(addr);
}
function clearAll() external {
list.clearAll();
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "../prize-strategy/multiple-winners/MultipleWinners.sol";
/// @title Creates a minimal proxy to the MultipleWinners prize strategy. Very cheap to deploy.
contract MultipleWinnersHarness is MultipleWinners {
uint256 public currentTime;
function setCurrentTime(uint256 _currentTime) external {
currentTime = _currentTime;
}
function _currentTime() internal override view returns (uint256) {
return currentTime;
}
function distribute(uint256 randomNumber) external {
_distribute(randomNumber);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;
import "./MultipleWinnersHarness.sol";
import "../external/openzeppelin/ProxyFactory.sol";
/// @title Creates a minimal proxy to the MultipleWinners prize strategy. Very cheap to deploy.
contract MultipleWinnersHarnessProxyFactory is ProxyFactory {
MultipleWinnersHarness public instance;
constructor () public {
instance = new MultipleWinnersHarness();
}
function create() external returns (MultipleWinnersHarness) {
return MultipleWinnersHarness(deployMinimal(address(instance), ""));
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../prize-strategy/PeriodicPrizeStrategy.sol";
/* solium-disable security/no-block-members */
interface PeriodicPrizeStrategyDistributorInterface {
function distribute(uint256 randomNumber) external;
}
pragma solidity >=0.6.0 <0.7.0;
import "../prize-strategy/PeriodicPrizeStrategy.sol";
import "./PeriodicPrizeStrategyDistributorInterface.sol";
import "@nomiclabs/buidler/console.sol";
/* solium-disable security/no-block-members */
contract PeriodicPrizeStrategyHarness is PeriodicPrizeStrategy {
PeriodicPrizeStrategyDistributorInterface distributor;
function setDistributor(PeriodicPrizeStrategyDistributorInterface _distributor) external {
distributor = _distributor;
}
uint256 internal time;
function setCurrentTime(uint256 _time) external {
time = _time;
}
function _currentTime() internal override view returns (uint256) {
return time;
}
function setRngRequest(uint32 requestId, uint32 lockBlock) external {
rngRequest.id = requestId;
rngRequest.lockBlock = lockBlock;
}
function _distribute(uint256 randomNumber) internal override {
console.log("random number: ", randomNumber);
distributor.distribute(randomNumber);
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../prize-pool/PrizePool.sol";
import "./YieldSourceStub.sol";
contract PrizePoolHarness is PrizePool {
uint256 public currentTime;
YieldSourceStub stubYieldSource;
function initializeAll(
RegistryInterface _reserveRegistry,
ControlledTokenInterface[] memory _controlledTokens,
uint256 _maxExitFeeMantissa,
uint256 _maxTimelockDuration,
YieldSourceStub _stubYieldSource
)
public
{
PrizePool.initialize(
_reserveRegistry,
_controlledTokens,
_maxExitFeeMantissa,
_maxTimelockDuration
);
stubYieldSource = _stubYieldSource;
}
function supply(uint256 mintAmount) external {
_supply(mintAmount);
}
function redeem(uint256 redeemAmount) external {
_redeem(redeemAmount);
}
function setCurrentTime(uint256 _currentTime) external {
currentTime = _currentTime;
}
function setTimelockBalance(uint256 _timelockBalance) external {
timelockTotalSupply = _timelockBalance;
}
function _currentTime() internal override view returns (uint256) {
return currentTime;
}
function _canAwardExternal(address _externalToken) internal override view returns (bool) {
return stubYieldSource.canAwardExternal(_externalToken);
}
function _token() internal override view returns (IERC20Upgradeable) {
return stubYieldSource.token();
}
function _balance() internal override returns (uint256) {
return stubYieldSource.balance();
}
function _supply(uint256 mintAmount) internal override {
return stubYieldSource.supply(mintAmount);
}
function _redeem(uint256 redeemAmount) internal override returns (uint256) {
return stubYieldSource.redeem(redeemAmount);
}
}
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
interface YieldSourceStub {
function canAwardExternal(address _externalToken) external view returns (bool);
function token() external view returns (IERC20Upgradeable);
function balance() external returns (uint256);
function supply(uint256 mintAmount) external;
function redeem(uint256 redeemAmount) external returns (uint256);
}
pragma solidity >=0.6.0 <0.7.0;
import "@pooltogether/pooltogether-rng-contracts/contracts/RNGInterface.sol";
contract RNGServiceMock is RNGInterface {
uint256 internal random;
address internal feeToken;
uint256 internal requestFee;
function getLastRequestId() external override view returns (uint32 requestId) {
return 1;
}
function setRequestFee(address _feeToken, uint256 _requestFee) external {
feeToken = _feeToken;
requestFee = _requestFee;
}
/// @return _feeToken
/// @return _requestFee
function getRequestFee() external override view returns (address _feeToken, uint256 _requestFee) {
return (feeToken, requestFee);
}
function setRandomNumber(uint256 _random) external {
random = _random;
}
function requestRandomNumber() external override returns (uint32, uint32) {
return (1, 1);
}
function isRequestComplete(uint32) external override view returns (bool) {
return true;
}
function randomNumber(uint32) external override returns (uint256) {
return random;
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../prize-strategy/single-random-winner/SingleRandomWinner.sol";
/* solium-disable security/no-block-members */
contract SingleRandomWinnerHarness is SingleRandomWinner {
uint256 internal time;
function setCurrentTime(uint256 _time) external {
time = _time;
}
function _currentTime() internal override view returns (uint256) {
return time;
}
function setRngRequest(uint32 requestId, uint32 lockBlock) external {
rngRequest.id = requestId;
rngRequest.lockBlock = lockBlock;
}
function distribute(uint256 randomNumber) external {
_distribute(randomNumber);
}
}
pragma solidity >=0.6.0 <0.7.0;
/* solium-disable security/no-block-members */
contract Timestamp {
function blockTime() public view returns (uint256) {
return block.timestamp;
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../utils/UInt256Array.sol";
contract UInt256ArrayExposed {
using UInt256Array for uint256[];
uint256[] internal array;
constructor (uint256[] memory _array) public {
array = new uint256[](_array.length);
for (uint256 i = 0; i < _array.length; i++) {
array[i] = _array[i];
}
}
function remove(uint256 index) external {
array.remove(index);
}
function toArray() external view returns (uint256[] memory) {
return array;
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../drip/VolumeDrip.sol";
contract VolumeDripExposed {
using VolumeDrip for VolumeDrip.State;
event DripTokensBurned(address user, uint256 amount);
event Minted(uint256 amount);
event MintedTotalSupply(uint256 amount);
VolumeDrip.State state;
function setNewPeriod(uint32 periodSeconds, uint112 dripAmount, uint32 endTime) external {
state.setNewPeriod(periodSeconds, dripAmount, endTime);
}
function setNextPeriod(uint32 periodSeconds, uint112 dripAmount) external {
state.setNextPeriod(periodSeconds, dripAmount);
}
function drip(uint256 currentTime, uint256 maxNewTokens) external returns (uint256) {
uint256 newTokens = state.drip(currentTime, maxNewTokens);
emit MintedTotalSupply(newTokens);
return newTokens;
}
function mint(address user, uint256 amount) external returns (uint256) {
uint256 accrued = state.mint(user, amount);
emit Minted(accrued);
return accrued;
}
function getDrip()
external
view
returns (
uint32 periodSeconds,
uint128 dripAmount
)
{
periodSeconds = state.nextPeriodSeconds;
dripAmount = state.nextDripAmount;
}
function getPeriod(uint32 period)
external
view
returns (
uint112 totalSupply,
uint112 dripAmount,
uint32 endTime
)
{
totalSupply = state.periods[period].totalSupply;
endTime = state.periods[period].endTime;
dripAmount = state.periods[period].dripAmount;
}
function getDeposit(address user)
external
view
returns (
uint112 balance,
uint32 period
)
{
balance = state.deposits[user].balance;
period = state.deposits[user].period;
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../drip/VolumeDripManager.sol";
contract VolumeDripManagerExposed {
using VolumeDripManager for VolumeDripManager.State;
using VolumeDrip for VolumeDrip.State;
VolumeDripManager.State manager;
function activate(
address measure,
address dripToken,
uint32 periodSeconds,
uint112 dripAmount,
uint32 endTime
)
external
{
manager.activate(measure, dripToken, periodSeconds, dripAmount, endTime);
}
function deactivate(
address measure,
address dripToken,
address prevDripToken
)
external
{
manager.deactivate(measure, dripToken, prevDripToken);
}
function set(address measure, address dripToken, uint32 periodSeconds, uint112 dripAmount) external {
manager.set(measure, dripToken, periodSeconds, dripAmount);
}
function isActive(address measure, address dripToken) external view returns (bool) {
return manager.isActive(measure, dripToken);
}
function getPeriod(
address measure,
address dripToken,
uint32 period
)
external
view
returns (
uint112 totalSupply,
uint112 dripAmount,
uint32 endTime
)
{
VolumeDrip.State storage drip = manager.getDrip(measure, dripToken);
VolumeDrip.Period memory state = drip.periods[period];
totalSupply = state.totalSupply;
dripAmount = state.dripAmount;
endTime = state.endTime;
}
function getActiveVolumeDrips(address measure) external view returns (address[] memory) {
return manager.getActiveVolumeDrips(measure);
}
function getDrip(
address measure,
address dripToken
)
external
view
returns (
uint32 periodSeconds,
uint112 dripAmount
)
{
VolumeDrip.State storage drip = manager.getDrip(measure, dripToken);
dripAmount = drip.nextDripAmount;
periodSeconds = drip.nextPeriodSeconds;
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../external/yearn/yVaultInterface.sol";
import "./ERC20Mintable.sol";
import "@pooltogether/fixed-point/contracts/FixedPoint.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
contract yVaultMock is yVaultInterface, ERC20Upgradeable {
ERC20Upgradeable private asset;
uint256 public vaultFeeMantissa;
constructor (ERC20Mintable _asset) public {
asset = _asset;
vaultFeeMantissa = 0.05 ether;
}
function token() external override view returns (IERC20Upgradeable) {
return asset;
}
function balance() public override view returns (uint) {
return asset.balanceOf(address(this));
}
function removeLiquidity(uint _amount) external {
asset.transfer(msg.sender, _amount);
}
function setVaultFeeMantissa(uint256 _vaultFeeMantissa) external {
vaultFeeMantissa = _vaultFeeMantissa;
}
function deposit(uint _amount) external override {
uint _pool = balance();
uint _before = asset.balanceOf(address(this));
asset.transferFrom(msg.sender, address(this), _amount);
uint _after = asset.balanceOf(address(this));
uint diff = _after.sub(_before); // Additional check for deflationary assets
uint shares = 0;
if (totalSupply() == 0) {
shares = diff;
} else {
shares = (diff.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
}
function withdraw(uint _shares) external override {
uint256 sharesFee = FixedPoint.multiplyUintByMantissa(_shares, vaultFeeMantissa);
uint256 withdrawal = (balance().mul(_shares.sub(sharesFee))).div(totalSupply());
asset.transfer(msg.sender, withdrawal);
_mint(address(this), sharesFee);
_burn(msg.sender, _shares);
}
function getPricePerFullShare() external override view returns (uint) {
return balance().mul(1e18).div(totalSupply());
}
}
pragma solidity >=0.6.0 <0.7.0;
import "../prize-pool/yearn/yVaultPrizePool.sol";
contract yVaultPrizePoolHarness is yVaultPrizePool {
uint256 public currentTime;
function setCurrentTime(uint256 _currentTime) external {
currentTime = _currentTime;
}
function _currentTime() internal override view returns (uint256) {
return currentTime;
}
function supply(uint256 mintAmount) external {
_supply(mintAmount);
}
function redeem(uint256 redeemAmount) external returns (uint256) {
return _redeem(redeemAmount);
}
}
pragma solidity >=0.6.0 <0.7.0;
import "./yVaultPrizePoolHarness.sol";
import "../external/openzeppelin/ProxyFactory.sol";
/// @title Compound Prize Pool Proxy Factory
/// @notice Minimal proxy pattern for creating new Compound Prize Pools
contract yVaultPrizePoolHarnessProxyFactory is ProxyFactory {
/// @notice Contract template for deploying proxied Prize Pools
yVaultPrizePoolHarness public instance;
/// @notice Initializes the Factory with an instance of the Compound Prize Pool
constructor () public {
instance = new yVaultPrizePoolHarness();
}
/// @notice Creates a new Compound Prize Pool as a proxy of the template instance
/// @return A reference to the new proxied Compound Prize Pool
function create() external returns (yVaultPrizePoolHarness) {
return yVaultPrizePoolHarness(deployMinimal(address(instance), ""));
}
}
| * @author Brendan Asselstine @notice A library that uses entropy to select a random number within a bound. Compensates for modulo bias./ | library UniformRandomNumber {
Copyright 2019 PoolTogether LLC
function uniform(uint256 _entropy, uint256 _upperBound) internal pure returns (uint256) {
require(_upperBound > 0, "UniformRand/min-bound");
uint256 min = -_upperBound % _upperBound;
uint256 random = _entropy;
while (true) {
if (random >= min) {
break;
}
random = uint256(keccak256(abi.encodePacked(random)));
}
return random % _upperBound;
}
function uniform(uint256 _entropy, uint256 _upperBound) internal pure returns (uint256) {
require(_upperBound > 0, "UniformRand/min-bound");
uint256 min = -_upperBound % _upperBound;
uint256 random = _entropy;
while (true) {
if (random >= min) {
break;
}
random = uint256(keccak256(abi.encodePacked(random)));
}
return random % _upperBound;
}
function uniform(uint256 _entropy, uint256 _upperBound) internal pure returns (uint256) {
require(_upperBound > 0, "UniformRand/min-bound");
uint256 min = -_upperBound % _upperBound;
uint256 random = _entropy;
while (true) {
if (random >= min) {
break;
}
random = uint256(keccak256(abi.encodePacked(random)));
}
return random % _upperBound;
}
}
| 12,863,539 | [
1,
38,
20262,
304,
4725,
292,
334,
558,
225,
432,
5313,
716,
4692,
15943,
358,
2027,
279,
2744,
1300,
3470,
279,
2489,
18,
225,
5427,
773,
815,
364,
26109,
12005,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
12083,
1351,
6854,
8529,
1854,
288,
203,
2951,
4083,
30562,
8828,
56,
717,
2437,
511,
13394,
203,
203,
225,
445,
10823,
12,
11890,
5034,
389,
21937,
16,
2254,
5034,
389,
5797,
3499,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
565,
2583,
24899,
5797,
3499,
405,
374,
16,
315,
13004,
54,
464,
19,
1154,
17,
3653,
8863,
203,
565,
2254,
5034,
1131,
273,
300,
67,
5797,
3499,
738,
389,
5797,
3499,
31,
203,
565,
2254,
5034,
2744,
273,
389,
21937,
31,
203,
565,
1323,
261,
3767,
13,
288,
203,
1377,
309,
261,
9188,
1545,
1131,
13,
288,
203,
3639,
898,
31,
203,
1377,
289,
203,
1377,
2744,
273,
2254,
5034,
12,
79,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
9188,
3719,
1769,
203,
565,
289,
203,
565,
327,
2744,
738,
389,
5797,
3499,
31,
203,
225,
289,
203,
225,
445,
10823,
12,
11890,
5034,
389,
21937,
16,
2254,
5034,
389,
5797,
3499,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
565,
2583,
24899,
5797,
3499,
405,
374,
16,
315,
13004,
54,
464,
19,
1154,
17,
3653,
8863,
203,
565,
2254,
5034,
1131,
273,
300,
67,
5797,
3499,
738,
389,
5797,
3499,
31,
203,
565,
2254,
5034,
2744,
273,
389,
21937,
31,
203,
565,
1323,
261,
3767,
13,
288,
203,
1377,
309,
261,
9188,
1545,
1131,
13,
288,
203,
3639,
898,
31,
203,
1377,
289,
203,
1377,
2744,
273,
2254,
5034,
12,
79,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
9188,
3719,
1769,
203,
565,
2
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
//import { LimitOrderBuilder, LimitOrderProtocolFacade } from "@1inch/limit-order-protocol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/lib/contracts/libraries/Babylonian.sol";
import "@uniswap/lib/contracts/libraries/TransferHelper.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
//import "@uniswap/v2-periphery/contracts/libraries/SafeMath.sol";
import "@uniswap/v2-periphery/contracts/libraries/UniswapV2Library.sol";
/// The Uniswap version of this contract is based on a token swap example provided by Uniswap
/// 1inch and other AMM/pool version are yet to be implemented
contract TokenSwapService {
using SafeERC20 for IERC20;
using SafeMath for uint256;
////**** Use 1inch as the service provider */
// Current 1inch limit order protocol deployment address guide:
// https://github.com/1inch/limit-order-protocol
//address constant limitOrderProtocolAddress_1inch = 0xa218543cc21ee9388Fa1E509F950FD127Ca82155; // Kovan
////**** Use Uniswap as the service provider */
///constructor (address _tokenIn) public {
/// IERC20(_tokenIn).safeApprove(address(uniswapRouter), type(uint256).max);
///}
/// UniswapV2Factory deployed address
address constant uniswapV2FactoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
/// UniswapV2Router02 deployed address
address constant uniswapV2Router02Address = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public router;
address public factory;
/**
* Constructor
*/
constructor() public {
factory = uniswapV2FactoryAddress;
router = IUniswapV2Router02(uniswapV2Router02Address);
}
/**
* Computes the direction and magnitude of the profit-maximizing token swap trade
* by getting true price via Chainlink oracle instead of counting on pool price
*/
function computeProfitMaximizingTrade(
uint256 truePriceTokenA,
uint256 truePriceTokenB,
uint256 reserveA,
uint256 reserveB
) pure public returns (bool aToB, uint256 amountIn) {
/// Always swap A into B for the Market Neutral pairs trade algo
aToB = true;
/// Will allow arbitrage trade in other algos later which will dynamic swap direction as follows:
/// aToB = SafeMath.div( SafeMath.mul(reserveA, truePriceTokenB)), reserveB ) < truePriceTokenA;
uint256 invariant = SafeMath.mul(reserveA, reserveB);
uint256 leftSide = Babylonian.sqrt(
SafeMath.div( SafeMath.mul( SafeMath.mul(invariant, (aToB ? truePriceTokenA : truePriceTokenB)), 1000 ),
SafeMath.mul( uint256(aToB ? truePriceTokenB : truePriceTokenA), 997 ) )
);
uint256 rightSide = SafeMath.div( (aToB ? (SafeMath.mul(reserveA, 1000)) : (SafeMath.mul(reserveB, 1000))), 997 );
/// Compute the amount that must be sent to move the price to the profit-maximizing price
amountIn = SafeMath.sub(leftSide, rightSide);
}
/**
* Swaps an amount of either token such that the trade is profit-maximizing, given an external true price
* via Chainlink oracle - which is expressed in the ratio of token A to token B
* caller must approve this contract to spend whichever token intended to be swapped
*/
function tradeOnUniswapV2(
address tokenA,
address tokenB,
uint256 truePriceTokenA,
uint256 truePriceTokenB,
uint256 maxSpendTokenA,
uint256 maxSpendTokenB,
address to,
uint256 deadline
) public returns (uint256) {
/// True price is expressed as a ratio, so both values must be non-zero
require(truePriceTokenA != 0 && truePriceTokenB != 0, "TokenSwapService: ZERO_PRICE");
/// Caller can specify 0 for either if they wish to swap in only one direction, but not both
require(maxSpendTokenA != 0 || maxSpendTokenB != 0, "TokenSwapService: ZERO_SPEND");
bool aToB;
uint256 amountIn;
{
(uint256 reserveA, uint256 reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
(aToB, amountIn) = computeProfitMaximizingTrade(
truePriceTokenA, truePriceTokenB,
reserveA, reserveB
);
}
/// Spend up to the allowance of the token in
uint256 maxSpend = aToB ? maxSpendTokenA : maxSpendTokenB;
if (amountIn > maxSpend) {
amountIn = maxSpend;
}
address tokenIn = aToB ? tokenA : tokenB;
address tokenOut = aToB ? tokenB : tokenA;
TransferHelper.safeTransferFrom(tokenIn, msg.sender, address(this), amountIn);
TransferHelper.safeApprove(tokenIn, address(router), amountIn);
address[] memory path = new address[](2);
path[0] = tokenIn;
path[1] = tokenOut;
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
amountIn,
0, /// amountOutMin: computing this number can be skipped because the math is tested
path,
to,
deadline
);
/**
router.swapExactTokensForTokens(
amountIn,
0, /// amountOutMin: computing this number can be skipped because the math is tested
path,
to,
deadline
); */
}
}
| The Uniswap version of this contract is based on a token swap example provided by Uniswap 1inch and other AMM/pool version are yet to be implemented Current 1inch limit order protocol deployment address guide: https:github.com/1inch/limit-order-protocoladdress constant limitOrderProtocolAddress_1inch = 0xa218543cc21ee9388Fa1E509F950FD127Ca82155; Kovan | contract TokenSwapService {
using SafeERC20 for IERC20;
using SafeMath for uint256;
address constant uniswapV2FactoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address constant uniswapV2Router02Address = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public router;
address public factory;
pragma solidity 0.6.12;
import "@uniswap/v2-periphery/contracts/libraries/UniswapV2Library.sol";
constructor() public {
factory = uniswapV2FactoryAddress;
router = IUniswapV2Router02(uniswapV2Router02Address);
}
function computeProfitMaximizingTrade(
uint256 truePriceTokenA,
uint256 truePriceTokenB,
uint256 reserveA,
uint256 reserveB
) pure public returns (bool aToB, uint256 amountIn) {
aToB = true;
uint256 invariant = SafeMath.mul(reserveA, reserveB);
uint256 leftSide = Babylonian.sqrt(
SafeMath.div( SafeMath.mul( SafeMath.mul(invariant, (aToB ? truePriceTokenA : truePriceTokenB)), 1000 ),
SafeMath.mul( uint256(aToB ? truePriceTokenB : truePriceTokenA), 997 ) )
);
uint256 rightSide = SafeMath.div( (aToB ? (SafeMath.mul(reserveA, 1000)) : (SafeMath.mul(reserveB, 1000))), 997 );
amountIn = SafeMath.sub(leftSide, rightSide);
}
function tradeOnUniswapV2(
address tokenA,
address tokenB,
uint256 truePriceTokenA,
uint256 truePriceTokenB,
uint256 maxSpendTokenA,
uint256 maxSpendTokenB,
address to,
uint256 deadline
) public returns (uint256) {
require(truePriceTokenA != 0 && truePriceTokenB != 0, "TokenSwapService: ZERO_PRICE");
require(maxSpendTokenA != 0 || maxSpendTokenB != 0, "TokenSwapService: ZERO_SPEND");
bool aToB;
uint256 amountIn;
{
(uint256 reserveA, uint256 reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
(aToB, amountIn) = computeProfitMaximizingTrade(
truePriceTokenA, truePriceTokenB,
reserveA, reserveB
);
}
if (amountIn > maxSpend) {
amountIn = maxSpend;
}
address tokenIn = aToB ? tokenA : tokenB;
address tokenOut = aToB ? tokenB : tokenA;
TransferHelper.safeTransferFrom(tokenIn, msg.sender, address(this), amountIn);
TransferHelper.safeApprove(tokenIn, address(router), amountIn);
address[] memory path = new address[](2);
path[0] = tokenIn;
path[1] = tokenOut;
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
amountIn,
path,
to,
deadline
);
amountIn,
path,
to,
deadline
); */
}
function tradeOnUniswapV2(
address tokenA,
address tokenB,
uint256 truePriceTokenA,
uint256 truePriceTokenB,
uint256 maxSpendTokenA,
uint256 maxSpendTokenB,
address to,
uint256 deadline
) public returns (uint256) {
require(truePriceTokenA != 0 && truePriceTokenB != 0, "TokenSwapService: ZERO_PRICE");
require(maxSpendTokenA != 0 || maxSpendTokenB != 0, "TokenSwapService: ZERO_SPEND");
bool aToB;
uint256 amountIn;
{
(uint256 reserveA, uint256 reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
(aToB, amountIn) = computeProfitMaximizingTrade(
truePriceTokenA, truePriceTokenB,
reserveA, reserveB
);
}
if (amountIn > maxSpend) {
amountIn = maxSpend;
}
address tokenIn = aToB ? tokenA : tokenB;
address tokenOut = aToB ? tokenB : tokenA;
TransferHelper.safeTransferFrom(tokenIn, msg.sender, address(this), amountIn);
TransferHelper.safeApprove(tokenIn, address(router), amountIn);
address[] memory path = new address[](2);
path[0] = tokenIn;
path[1] = tokenOut;
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
amountIn,
path,
to,
deadline
);
amountIn,
path,
to,
deadline
); */
}
uint256 maxSpend = aToB ? maxSpendTokenA : maxSpendTokenB;
function tradeOnUniswapV2(
address tokenA,
address tokenB,
uint256 truePriceTokenA,
uint256 truePriceTokenB,
uint256 maxSpendTokenA,
uint256 maxSpendTokenB,
address to,
uint256 deadline
) public returns (uint256) {
require(truePriceTokenA != 0 && truePriceTokenB != 0, "TokenSwapService: ZERO_PRICE");
require(maxSpendTokenA != 0 || maxSpendTokenB != 0, "TokenSwapService: ZERO_SPEND");
bool aToB;
uint256 amountIn;
{
(uint256 reserveA, uint256 reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
(aToB, amountIn) = computeProfitMaximizingTrade(
truePriceTokenA, truePriceTokenB,
reserveA, reserveB
);
}
if (amountIn > maxSpend) {
amountIn = maxSpend;
}
address tokenIn = aToB ? tokenA : tokenB;
address tokenOut = aToB ? tokenB : tokenA;
TransferHelper.safeTransferFrom(tokenIn, msg.sender, address(this), amountIn);
TransferHelper.safeApprove(tokenIn, address(router), amountIn);
address[] memory path = new address[](2);
path[0] = tokenIn;
path[1] = tokenOut;
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
amountIn,
path,
to,
deadline
);
amountIn,
path,
to,
deadline
); */
}
router.swapExactTokensForTokens(
}
| 14,053,675 | [
1,
1986,
1351,
291,
91,
438,
1177,
434,
333,
6835,
353,
2511,
603,
279,
1147,
7720,
3454,
2112,
635,
1351,
291,
91,
438,
404,
267,
343,
471,
1308,
432,
8206,
19,
6011,
1177,
854,
4671,
358,
506,
8249,
6562,
404,
267,
343,
1800,
1353,
1771,
6314,
1758,
7343,
30,
2333,
30,
6662,
18,
832,
19,
21,
267,
343,
19,
3595,
17,
1019,
17,
8373,
2867,
5381,
1800,
2448,
5752,
1887,
67,
21,
267,
343,
273,
374,
6995,
22,
2643,
6564,
23,
952,
5340,
1340,
11180,
5482,
29634,
21,
41,
5995,
42,
29,
3361,
16894,
14260,
23508,
28,
5340,
2539,
31,
377,
1475,
1527,
304,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
3155,
12521,
1179,
288,
203,
565,
1450,
14060,
654,
39,
3462,
364,
467,
654,
39,
3462,
31,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
377,
203,
203,
377,
203,
377,
203,
565,
1758,
5381,
640,
291,
91,
438,
58,
22,
1733,
1887,
273,
374,
92,
25,
39,
8148,
70,
41,
73,
27,
1611,
10241,
28,
3461,
69,
22,
38,
26,
69,
23,
2056,
40,
24,
38,
2313,
9401,
8876,
29,
952,
25,
69,
37,
26,
74,
31,
203,
565,
1758,
5381,
640,
291,
91,
438,
58,
22,
8259,
3103,
1887,
273,
374,
92,
27,
69,
26520,
72,
4313,
5082,
38,
24,
71,
42,
25,
5520,
27,
5520,
72,
42,
22,
39,
25,
72,
37,
7358,
24,
71,
26,
6162,
42,
3247,
5482,
40,
31,
203,
203,
565,
467,
984,
291,
91,
438,
58,
22,
8259,
3103,
1071,
4633,
31,
203,
565,
1758,
1071,
3272,
31,
203,
203,
683,
9454,
18035,
560,
374,
18,
26,
18,
2138,
31,
203,
203,
5666,
8787,
318,
291,
91,
438,
19,
90,
22,
17,
457,
16045,
627,
19,
16351,
87,
19,
31417,
19,
984,
291,
91,
438,
58,
22,
9313,
18,
18281,
14432,
203,
565,
3885,
1435,
1071,
288,
203,
3639,
3272,
273,
640,
291,
91,
438,
58,
22,
1733,
1887,
31,
27699,
3639,
4633,
273,
467,
984,
291,
91,
438,
58,
22,
8259,
3103,
12,
318,
291,
91,
438,
58,
22,
8259,
3103,
1887,
1769,
203,
565,
289,
203,
203,
565,
445,
3671,
626,
7216,
2747,
381,
6894,
22583,
12,
203,
3639,
2254,
5034,
2
]
|
/*
Documentation: https://arbitria.readthedocs.io
Author: Brandon Chaffee
License: MIT
*/
pragma solidity ^0.4.23;
import "./BlockableTransfer.sol";
contract GenericModification is BlockableTransfer {
// GMs1 (Modification Appendix)
Modification[] public modifications;
// GMs2 (Modification Appendix)
uint256 public windowSize;
// GMs3 (Modification Appendix)
struct Modification {
bytes4 signature;
bytes32[] payload;
uint256 windowEnd;
bool isValid;
uint yesTotal;
uint noTotal;
mapping(address => uint) yesVotesOf;
mapping(address => uint) noVotesOf;
bool hasBeenConfirmed;
}
// GMs4 (Modification Appendix)
modifier fromContract() {
require(msg.sender == address(this));
_;
}
event ModificationCreated(
bytes4 indexed signature,
bytes32[] payload,
uint256 indexed windowEnd,
uint256 indexed id,
bytes32 detailsHash
);
// GMf1 (Modification Appendix)
function createModification(bytes4 _sig, bytes32[] _payload, bytes32 _hash)
public returns(uint256){
uint256 _id = modifications.length++;
Modification storage m = modifications[_id];
m.signature = _sig;
m.payload = _payload;
m.windowEnd = now + windowSize;
emit ModificationCreated(_sig, _payload, m.windowEnd, _id, _hash);
return _id;
}
// GMf2 (Modification Appendix)
function unblockTransfer() public {
for(uint i=0; i < inVote[msg.sender].length; i++){
Modification storage m = modifications[i];
m.noTotal -= m.noVotesOf[msg.sender];
m.noVotesOf[msg.sender] = 0;
m.yesTotal -= m.yesVotesOf[msg.sender];
m.yesVotesOf[msg.sender] = 0;
}
delete inVote[msg.sender];
}
// GMf3 (Modification Appendix)
function accountVotes(uint256 _id, bool _approve) internal {
Modification storage m = modifications[_id];
if(_approve){
m.yesTotal -= m.yesVotesOf[msg.sender];
m.noTotal -= m.noVotesOf[msg.sender];
m.noVotesOf[msg.sender] = 0;
m.yesVotesOf[msg.sender] = balances[msg.sender];
m.yesTotal += balances[msg.sender];
} else {
m.noTotal -= m.noVotesOf[msg.sender];
m.yesTotal -= m.yesVotesOf[msg.sender];
m.yesVotesOf[msg.sender] = 0;
m.noVotesOf[msg.sender] = balances[msg.sender];
m.noTotal += balances[msg.sender];
}
}
event ModificationCalled(uint256 _id, uint256 _time);
// GMf4 (Modification Appendix)
function confirmModification(uint256 _id) public {
Modification storage m = modifications[_id];
require(now >= m.windowEnd);
require(m.isValid);
require(!m.hasBeenConfirmed);
m.hasBeenConfirmed = true;
emit ModificationCalled(_id, now);
callModification(m.signature, m.payload);
}
// GMf5 (Modification Appendix)
function callModification(bytes4 sig, bytes32[] payload) internal {
assembly {
let offset := 0x04
let len := add(offset, mul(mload(payload), 0x20))
let data := add(payload, 0x20)
let x := mload(0x40)
mstore(x,sig)
for {} lt(offset, len) {
offset := add(offset, 0x20)
data := add(data, 0x20)
}{
mstore(add(x,offset),mload(data))
}
let success := call(gas, address, 0, x, msize, x, 0x20)
mstore(0x40,add(x,msize))
}
}
}
| GMf2 (Modification Appendix) | function unblockTransfer() public {
for(uint i=0; i < inVote[msg.sender].length; i++){
Modification storage m = modifications[i];
m.noTotal -= m.noVotesOf[msg.sender];
m.noVotesOf[msg.sender] = 0;
m.yesTotal -= m.yesVotesOf[msg.sender];
m.yesVotesOf[msg.sender] = 0;
}
delete inVote[msg.sender];
}
| 14,093,548 | [
1,
43,
49,
74,
22,
261,
13467,
6181,
697,
13,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
640,
2629,
5912,
1435,
1071,
288,
203,
3639,
364,
12,
11890,
277,
33,
20,
31,
277,
411,
316,
19338,
63,
3576,
18,
15330,
8009,
2469,
31,
277,
27245,
95,
203,
5411,
3431,
1480,
2502,
312,
273,
17953,
63,
77,
15533,
203,
5411,
312,
18,
2135,
5269,
3947,
312,
18,
2135,
29637,
951,
63,
3576,
18,
15330,
15533,
203,
5411,
312,
18,
2135,
29637,
951,
63,
3576,
18,
15330,
65,
273,
374,
31,
203,
5411,
312,
18,
9707,
5269,
3947,
312,
18,
9707,
29637,
951,
63,
3576,
18,
15330,
15533,
203,
5411,
312,
18,
9707,
29637,
951,
63,
3576,
18,
15330,
65,
273,
374,
31,
203,
3639,
289,
203,
3639,
1430,
316,
19338,
63,
3576,
18,
15330,
15533,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0x25C7C475934f40908523a36d5d7ea810D890b50F/sources/contracts/universal/MultiSigWallet.sol | * @inheritdoc IMultiSigWallet/ | function executeTransaction(uint256 _transactionId) external ownerExists(msg.sender) {
_executeTransaction(_transactionId);
}
| 16,187,015 | [
1,
36,
10093,
467,
5002,
8267,
16936,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
1836,
3342,
12,
11890,
5034,
389,
7958,
548,
13,
3903,
3410,
4002,
12,
3576,
18,
15330,
13,
288,
203,
3639,
389,
8837,
3342,
24899,
7958,
548,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity ^0.8.4;
import "./Math.sol";
import "./SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TWAMMSwap is Ownable {
using SafeMath for uint;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
IERC20 public token0;
IERC20 public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint private twammTimestampLast; // uses single storage slot, accessible via getReserves
uint public buy0PerSecond;
uint public buy1PerSecond;
uint public sell0PerSecond;
uint public sell2PerSecond;
uint public buy0EndTime;
uint public buy1EndTime;
uint public bought0;
uint public bought1;
uint public sold0;
uint public sold1;
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'TWAPP: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint _twammTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_twammTimestampLast = twammTimestampLast;
}
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
constructor(IERC20 _token0, IERC20 _token1) {
token0 = _token0;
token1 = _token1;
}
/* External TWAMM functions for owner */
// Set the TWAMMTrade to execute
function setTWAMMTrade(uint _buy0PerSecond,uint _buy0EndTime, uint _buy1PerSecond, uint _buy1EndTime) external lock onlyOwner {
_executeTWAMMTrade();
buy0PerSecond = _buy0PerSecond;
buy0EndTime = _buy0EndTime;
buy1PerSecond = _buy1PerSecond;
buy1EndTime = _buy1EndTime;
twammTimestampLast=block.timestamp;
uint balance0 = IERC20(token0).balanceOf(address(this)).add(sold0).sub(bought0);
uint balance1 = IERC20(token1).balanceOf(address(this)).add(sold1).sub(bought1);
_update(balance0, balance1);
}
// Execute the swap
function executeTWAMMSwap() external lock onlyOwner {
if (sold0>0 && bought0<sold0) SafeERC20.safeTransferFrom(token0, msg.sender, address(this), sold0-bought0);
if (sold1>0 && bought1<sold1) SafeERC20.safeTransferFrom(token1, msg.sender, address(this), sold1-bought1);
if (bought0>0 && bought0>sold0) SafeERC20.safeTransfer(token0, msg.sender, bought0-sold0);
if (bought1>0 && bought1>sold1) SafeERC20.safeTransfer(token1, msg.sender, bought1-sold1);
bought0 = bought1 = sold0 = sold1 = 0;
}
/* External add remove liquidity functions for owner */
// Removes liquidity
function removeLiquidity(uint percentage) external lock onlyOwner returns (uint amount0, uint amount1) {
_executeTWAMMTrade();
uint balance0 = IERC20(token0).balanceOf(address(this)).add(sold0).sub(bought0);
uint balance1 = IERC20(token1).balanceOf(address(this)).add(sold1).sub(bought1);
amount0 = balance0*percentage/1e18;
amount1 = balance1*percentage/1e18;
SafeERC20.safeTransfer(token0, msg.sender, amount0);
SafeERC20.safeTransfer(token1, msg.sender, amount1);
balance0 = IERC20(token0).balanceOf(address(this)).add(sold0).sub(bought0);
balance1 = IERC20(token1).balanceOf(address(this)).add(sold1).sub(bought1);
_update(balance0, balance1);
}
// Adds liquidity
function addLiquidity(uint token0Amount, uint token1Amount, uint min_token1Amount, uint max_token1Amount) external lock onlyOwner {
_executeTWAMMTrade();
uint balance0 = IERC20(token0).balanceOf(address(this)).add(sold0).sub(bought0);
uint balance1 = IERC20(token1).balanceOf(address(this)).add(sold1).sub(bought1);
if (balance1>0) token1Amount = balance0*balance1/token0Amount; // adjust token1Amount to match the ratio
require(token1Amount>=min_token1Amount && token1Amount<=max_token1Amount,'TWAPP: PRICE NOT WITHIN BOUNDS');
SafeERC20.safeTransferFrom(token0, msg.sender, address(this), token0Amount);
SafeERC20.safeTransferFrom(token1, msg.sender, address(this), token1Amount);
balance0 = IERC20(token0).balanceOf(address(this)).add(sold0).sub(bought0);
balance1 = IERC20(token1).balanceOf(address(this)).add(sold1).sub(bought1);
_update(balance0, balance1);
}
/* External swap function for end users */
function swapExactTokensForTokens(uint amountIn, uint amountOutMin, IERC20 tokenFrom, IERC20 tokenTo, address to, uint deadline) external lock returns (uint amount) {
require(deadline==0 || block.timestamp<=deadline,'TWAPP: EXPIRED');
_executeTWAMMTrade();
uint balance0 = IERC20(token0).balanceOf(address(this)).add(sold0).sub(bought0);
uint balance1 = IERC20(token1).balanceOf(address(this)).add(sold1).sub(bought1);
if (tokenFrom==token0 && tokenTo==token1) {
amount = getAmountOut(amountIn, balance0, balance1);
require(amount>=amountOutMin,'TWAPP: INSUFFICIENT_OUTPUT_AMOUNT');
SafeERC20.safeTransferFrom(token0, msg.sender, address(this), amountIn);
swap(0, amount, to);
} else if (tokenFrom==token1 && tokenTo==token0) {
amount = getAmountOut(amountIn, balance1, balance0);
require(amount>=amountOutMin,'TWAPP: INSUFFICIENT_OUTPUT_AMOUNT');
SafeERC20.safeTransferFrom(token1, msg.sender, address(this), amountIn);
swap(amount, 0, to);
}
}
/* External utility functions */
// force balances to match reserves
function skim(address to) external lock {
IERC20 _token0 = token0; // gas savings
IERC20 _token1 = token1; // gas savings
SafeERC20.safeTransfer(_token0, to, _token0.balanceOf(address(this)).add(bought0).sub(sold0).sub(reserve0));
SafeERC20.safeTransfer(_token1, to, _token1.balanceOf(address(this)).add(bought1).sub(sold1).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_executeTWAMMTrade();
_update(IERC20(token0).balanceOf(address(this)).add(sold0).sub(bought0), IERC20(token1).balanceOf(address(this)).add(sold1).sub(bought1));
}
/* Internal functions */
// update reserves
function _update(uint balance0, uint balance1) private {
require(balance0 <=type(uint112).max && balance1 <= type(uint112).max, 'TWAPP: OVERFLOW');
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
emit Sync(reserve0, reserve1);
}
// internal function that executes the TWAMM trade for the previous period
function _executeTWAMMTrade() internal {
if (block.timestamp>twammTimestampLast) {
if (buy0PerSecond>0 && twammTimestampLast<buy0EndTime) {
uint period = Math.min(buy0EndTime,block.timestamp) - twammTimestampLast;
uint bought = period*buy0PerSecond;
uint sold = getAmountIn(bought,reserve1,reserve0);
bought0+=bought;
sold1+=sold;
}
if (buy1PerSecond>0 && twammTimestampLast<buy1EndTime) {
uint period = Math.min(buy1EndTime,block.timestamp) - twammTimestampLast;
uint bought = period*buy1PerSecond;
uint sold = getAmountIn(bought,reserve0,reserve1);
bought1+=bought;
sold0+=sold;
}
twammTimestampLast = block.timestamp;
}
}
function swap(uint amount0Out, uint amount1Out, address to) internal {
require(amount0Out > 0 || amount1Out > 0, 'TWAPP: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'TWAPP: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
IERC20 _token0 = token0;
IERC20 _token1 = token1;
require(to != address(_token0) && to != address(_token1), 'TWAPP: INVALID_TO');
if (amount0Out > 0) SafeERC20.safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) SafeERC20.safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
//if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this)).add(sold0).sub(bought0);
balance1 = IERC20(_token1).balanceOf(address(this)).add(sold1).sub(bought1);
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'TWAPP: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'TWAPP: K');
}
_update(balance0, balance1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
/* Internal utility functions */
// given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'TWAPP: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'TWAPP: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// given an output amount of an asset and pair reserves, returns a required input amount of the other asset
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'TWAPP: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'TWAPP: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
}
| force balances to match reserves | function skim(address to) external lock {
SafeERC20.safeTransfer(_token0, to, _token0.balanceOf(address(this)).add(bought0).sub(sold0).sub(reserve0));
SafeERC20.safeTransfer(_token1, to, _token1.balanceOf(address(this)).add(bought1).sub(sold1).sub(reserve1));
}
| 2,496,710 | [
1,
5734,
324,
26488,
358,
845,
400,
264,
3324,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
4343,
381,
12,
2867,
358,
13,
3903,
2176,
288,
203,
3639,
14060,
654,
39,
3462,
18,
4626,
5912,
24899,
2316,
20,
16,
358,
16,
389,
2316,
20,
18,
12296,
951,
12,
2867,
12,
2211,
13,
2934,
1289,
12,
1075,
9540,
20,
2934,
1717,
12,
87,
1673,
20,
2934,
1717,
12,
455,
6527,
20,
10019,
203,
3639,
14060,
654,
39,
3462,
18,
4626,
5912,
24899,
2316,
21,
16,
358,
16,
389,
2316,
21,
18,
12296,
951,
12,
2867,
12,
2211,
13,
2934,
1289,
12,
1075,
9540,
21,
2934,
1717,
12,
87,
1673,
21,
2934,
1717,
12,
455,
6527,
21,
10019,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/10/0x91ba8A14D2CC851aBb69212c09f59e06e1e7f0a5/sources/project_/contracts/presets/ERC721EnviousDynamicPreset.sol | * @dev See {_baseURI}./ | function baseURI() external view virtual returns (string memory) {
return _baseURI();
}
| 3,784,387 | [
1,
9704,
288,
67,
1969,
3098,
5496,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
202,
915,
1026,
3098,
1435,
3903,
1476,
5024,
1135,
261,
1080,
3778,
13,
288,
203,
202,
202,
2463,
389,
1969,
3098,
5621,
203,
202,
97,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0x3558a74679b6993be1FA230a961D8a4f3EB2C330/sources/browser/ZOMDeFi.sol | * @title SafeERC20 @dev Wrappers around ERC20 operations that throw on failure (when the token contract returns false). Tokens that return no value (and instead revert or throw on failure) are also supported, non-reverting calls are assumed to be successful. To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, which allows you to call the safe operations as `token.safeTransfer(...)`, etc./ | library SafeERC20 {
using SafeMath for uint256;
using Address for address;
}
modifier onlyPayloadSize(uint256 size) {
assert(msg.data.length == size + 4);
_;
}
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
| 8,345,348 | [
1,
9890,
654,
39,
3462,
225,
4266,
10422,
6740,
4232,
39,
3462,
5295,
716,
604,
603,
5166,
261,
13723,
326,
1147,
6835,
1135,
629,
2934,
13899,
716,
327,
1158,
460,
261,
464,
3560,
15226,
578,
604,
603,
5166,
13,
854,
2546,
3260,
16,
1661,
17,
266,
1097,
310,
4097,
854,
12034,
358,
506,
6873,
18,
2974,
999,
333,
5313,
1846,
848,
527,
279,
1375,
9940,
14060,
654,
39,
3462,
364,
467,
654,
39,
3462,
31,
68,
3021,
358,
3433,
6835,
16,
1492,
5360,
1846,
358,
745,
326,
4183,
5295,
487,
1375,
2316,
18,
4626,
5912,
5825,
13,
9191,
5527,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
12083,
14060,
654,
39,
3462,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
565,
1450,
5267,
364,
1758,
31,
203,
203,
97,
203,
565,
9606,
1338,
6110,
1225,
12,
11890,
5034,
963,
13,
288,
203,
377,
1815,
12,
3576,
18,
892,
18,
2469,
422,
963,
397,
1059,
1769,
203,
377,
389,
31,
203,
282,
289,
203,
203,
565,
445,
4183,
5912,
12,
45,
654,
39,
3462,
1147,
16,
1758,
358,
16,
2254,
5034,
460,
13,
2713,
288,
203,
3639,
389,
1991,
6542,
990,
12,
2316,
16,
24126,
18,
3015,
1190,
4320,
12,
2316,
18,
13866,
18,
9663,
16,
358,
16,
460,
10019,
203,
565,
289,
203,
203,
565,
445,
4183,
5912,
1265,
12,
45,
654,
39,
3462,
1147,
16,
1758,
628,
16,
1758,
358,
16,
2254,
5034,
460,
13,
2713,
288,
203,
3639,
389,
1991,
6542,
990,
12,
2316,
16,
24126,
18,
3015,
1190,
4320,
12,
2316,
18,
13866,
1265,
18,
9663,
16,
628,
16,
358,
16,
460,
10019,
203,
565,
289,
203,
203,
565,
445,
4183,
12053,
537,
12,
45,
654,
39,
3462,
1147,
16,
1758,
17571,
264,
16,
2254,
5034,
460,
13,
2713,
288,
203,
3639,
2583,
12443,
1132,
422,
374,
13,
747,
261,
2316,
18,
5965,
1359,
12,
2867,
12,
2211,
3631,
17571,
264,
13,
422,
374,
3631,
203,
5411,
315,
9890,
654,
39,
3462,
30,
6617,
537,
628,
1661,
17,
7124,
358,
1661,
17,
7124,
1699,
1359,
6,
203,
3639,
11272,
203,
3639,
389,
1991,
6542,
990,
12,
2316,
16,
24126,
18,
3015,
1190,
4320,
12,
2316,
2
]
|
./full_match/1/0xefaCa6Fc316B3B2Aa6c55FF5E02a62A85d4391e8/sources/contracts/storage/Config.sol | * @title System wide configuration for anything/ | library Config {
pragma solidity >=0.8.11 <0.9.0;
struct Data {
uint256 __unused;
}
function read(bytes32 k) internal view returns (bytes32 v) {
bytes32 s = keccak256(abi.encode("Config", k));
assembly {
v := sload(s)
}
}
function read(bytes32 k) internal view returns (bytes32 v) {
bytes32 s = keccak256(abi.encode("Config", k));
assembly {
v := sload(s)
}
}
function put(bytes32 k, bytes32 v) internal {
bytes32 s = keccak256(abi.encode("Config", k));
assembly {
sstore(s, v)
}
}
function put(bytes32 k, bytes32 v) internal {
bytes32 s = keccak256(abi.encode("Config", k));
assembly {
sstore(s, v)
}
}
}
| 16,517,091 | [
1,
3163,
14812,
1664,
364,
6967,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
12083,
1903,
288,
203,
683,
9454,
18035,
560,
1545,
20,
18,
28,
18,
2499,
411,
20,
18,
29,
18,
20,
31,
203,
565,
1958,
1910,
288,
203,
3639,
2254,
5034,
1001,
14375,
31,
203,
565,
289,
203,
203,
565,
445,
855,
12,
3890,
1578,
417,
13,
2713,
1476,
1135,
261,
3890,
1578,
331,
13,
288,
203,
3639,
1731,
1578,
272,
273,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
2932,
809,
3113,
417,
10019,
203,
3639,
19931,
288,
203,
5411,
331,
519,
272,
945,
12,
87,
13,
203,
3639,
289,
203,
565,
289,
203,
203,
565,
445,
855,
12,
3890,
1578,
417,
13,
2713,
1476,
1135,
261,
3890,
1578,
331,
13,
288,
203,
3639,
1731,
1578,
272,
273,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
2932,
809,
3113,
417,
10019,
203,
3639,
19931,
288,
203,
5411,
331,
519,
272,
945,
12,
87,
13,
203,
3639,
289,
203,
565,
289,
203,
203,
565,
445,
1378,
12,
3890,
1578,
417,
16,
1731,
1578,
331,
13,
2713,
288,
203,
3639,
1731,
1578,
272,
273,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
2932,
809,
3113,
417,
10019,
203,
3639,
19931,
288,
203,
5411,
272,
2233,
12,
87,
16,
331,
13,
203,
3639,
289,
203,
565,
289,
203,
565,
445,
1378,
12,
3890,
1578,
417,
16,
1731,
1578,
331,
13,
2713,
288,
203,
3639,
1731,
1578,
272,
273,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
2932,
809,
3113,
417,
10019,
203,
3639,
19931,
288,
203,
5411,
272,
2233,
12,
87,
16,
331,
13,
203,
3639,
289,
2
]
|
./full_match/1/0x268Fc6C5Eb17BE53a8670895be62B414c3E636Ce/sources/contracts/priceProviders/uniswapV3/UniswapV3PriceProviderV3.sol | @notice Emitted when blockTime changes @param blockTime block time in seconds | event NewBlockTime(uint8 blockTime);
| 16,486,652 | [
1,
1514,
11541,
1347,
1203,
950,
3478,
225,
1203,
950,
1203,
813,
316,
3974,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
871,
1166,
1768,
950,
12,
11890,
28,
1203,
950,
1769,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
/**
*Submitted for verification at Etherscan.io on 2021-08-03
*/
// File: @openzeppelin/contracts/utils/math/SafeMath.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
// File: @openzeppelin/contracts/security/ReentrancyGuard.sol
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
pragma solidity ^0.8.0;
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: LatticeStakingPool.sol
pragma solidity 0.8.6;
contract LatticeStakingPool is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct StakingPool {
uint256 maxStakingAmountPerUser;
uint256 totalAmountStaked;
address[] usersStaked;
}
struct Project {
string name;
uint256 totalAmountStaked;
uint256 numberOfPools;
uint256 startBlock;
uint256 endBlock;
}
struct UserInfo{
address userAddress;
uint256 poolId;
uint256 percentageOfTokensStakedInPool;
uint256 amountOfTokensStakedInPool;
}
IERC20 public stakingToken;
address private owner;
Project[] public projects;
/// @notice ProjectID => WhitelistedAddress
mapping(uint256 => mapping(address => bool)) public projectIdToWhitelistedAddress;
/// @notice ProjectID => WhitelistedArray
mapping(uint256 => address[]) private projectIdToWhitelistedArray;
/// @notice ProjectID => Pool ID => User Address => amountStaked
mapping(uint256 => mapping(uint256 => mapping(address => uint256))) public userStakedAmount;
/// @notice ProjectID => Pool ID => User Address => didUserWithdrawFunds
mapping(uint256 => mapping(uint256 => mapping(address => bool))) public didUserWithdrawFunds;
/// @notice ProjectID => Pool ID => StakingPool
mapping(uint256 => mapping(uint256 => StakingPool)) public stakingPoolInfo;
/// @notice ProjectName => isProjectNameTaken
mapping(string=>bool) public isProjectNameTaken;
/// @notice ProjectName => ProjectID
mapping(string=>uint256) public projectNameToProjectId;
event Deposit(
address indexed _user,
uint256 indexed _projectId,
uint256 indexed _poolId,
uint256 _amount
);
event Withdraw(
address indexed _user,
uint256 indexed _projectId,
uint256 indexed _poolId,
uint256 _amount
);
event PoolAdded(uint256 indexed _projectId, uint256 indexed _poolId);
event ProjectDisabled(uint256 indexed _projectId);
event ProjectAdded(uint256 indexed _projectId, string _projectName);
constructor(IERC20 _stakingToken) {
require(
address(_stakingToken) != address(0),
"constructor: _stakingToken must not be zero address"
);
owner = msg.sender;
stakingToken = _stakingToken;
}
function addProject(string memory _name, uint256 _startBlock, uint256 _endBlock) external {
require(msg.sender == owner, "addNewProject: Caller is not the owner");
require(bytes(_name).length > 0 , "addNewProject: Project name cannot be empty string.");
require(
_startBlock >= block.number,
"addNewProject: startBlock is less than the current block number."
);
require(
_startBlock < _endBlock,
"addNewProject: startBlock is greater than or equal to the endBlock."
);
require(!isProjectNameTaken[_name], "addNewProject: project name already taken.");
Project memory project;
project.name = _name;
project.startBlock = _startBlock;
project.endBlock = _endBlock;
project.numberOfPools = 0;
project.totalAmountStaked = 0;
uint256 projectsLength = projects.length;
projects.push(project);
projectNameToProjectId[_name] = projectsLength;
isProjectNameTaken[_name] = true;
emit ProjectAdded(projectsLength, _name);
}
function addStakingPool(uint256 _projectId, uint256 _maxStakingAmountPerUser) external {
require(msg.sender == owner, "addStakingPool: Caller is not the owner.");
require(_projectId < projects.length, "addStakingPool: Invalid project ID.");
StakingPool memory stakingPool;
stakingPool.maxStakingAmountPerUser = _maxStakingAmountPerUser;
stakingPool.totalAmountStaked=0;
uint256 numberOfPoolsInProject = projects[_projectId].numberOfPools;
stakingPoolInfo[_projectId][numberOfPoolsInProject] = stakingPool;
projects[_projectId].numberOfPools = projects[_projectId].numberOfPools+1;
emit PoolAdded(_projectId,projects[_projectId].numberOfPools);
}
function disableProject(uint256 _projectId) external {
require(msg.sender == owner, "disableProject: Caller is not the owner");
require(_projectId < projects.length, "disableProject: Invalid project ID.");
projects[_projectId].endBlock = block.number;
emit ProjectDisabled(_projectId);
}
function deposit (uint256 _projectId, uint256 _poolId, uint256 _amount) external nonReentrant {
require(
projectIdToWhitelistedAddress[_projectId][msg.sender],
"deposit: Address is not whitelisted for this project."
);
require(_amount > 0, "deposit: Amount not specified.");
require(_projectId < projects.length, "deposit: Invalid project ID.");
require(_poolId < projects[_projectId].numberOfPools, "deposit: Invalid pool ID.");
require(
block.number <= projects[_projectId].endBlock,
"deposit: Staking no longer permitted for this project."
);
require(
block.number >= projects[_projectId].startBlock,
"deposit: Staking is not yet permitted for this project."
);
uint256 _userStakedAmount = userStakedAmount[_projectId][_poolId][msg.sender];
if(stakingPoolInfo[_projectId][_poolId].maxStakingAmountPerUser > 0){
require(
_userStakedAmount.add(_amount) <= stakingPoolInfo[_projectId][_poolId].maxStakingAmountPerUser,
"deposit: Cannot exceed max staking amount per user."
);
}
if(userStakedAmount[_projectId][_poolId][msg.sender] == 0){
stakingPoolInfo[_projectId][_poolId].usersStaked.push(msg.sender);
}
projects[_projectId].totalAmountStaked
= projects[_projectId].totalAmountStaked.add(_amount);
stakingPoolInfo[_projectId][_poolId].totalAmountStaked
= stakingPoolInfo[_projectId][_poolId].totalAmountStaked.add(_amount);
userStakedAmount[_projectId][_poolId][msg.sender]
= userStakedAmount[_projectId][_poolId][msg.sender].add(_amount);
stakingToken.safeTransferFrom(address(msg.sender), address(this), _amount);
emit Deposit(msg.sender, _projectId, _poolId, _amount);
}
function withdraw (uint256 _projectId, uint256 _poolId) external nonReentrant {
require(
projectIdToWhitelistedAddress[_projectId][msg.sender],
"withdraw: Address is not whitelisted for this project."
);
require(_projectId < projects.length, "withdraw: Invalid project ID.");
require(_poolId < projects[_projectId].numberOfPools, "withdraw: Invalid pool ID.");
require(block.number > projects[_projectId].endBlock, "withdraw: Not yet permitted.");
require(
!didUserWithdrawFunds[_projectId][_poolId][msg.sender],
"withdraw: User has already withdrawn funds for this pool."
);
uint256 _userStakedAmount = userStakedAmount[_projectId][_poolId][msg.sender];
require(_userStakedAmount > 0, "withdraw: No stake to withdraw.");
didUserWithdrawFunds[_projectId][_poolId][msg.sender] = true;
stakingToken.safeTransfer(msg.sender, _userStakedAmount);
emit Withdraw(msg.sender, _projectId, _poolId, _userStakedAmount);
}
function whitelistAddresses(
uint256 _projectId,
address[] memory _newAddressesToWhitelist
) external {
require(msg.sender == owner, "whitelistAddresses: Caller is not the owner");
require(_projectId < projects.length, "whitelistAddresses: Invalid project ID.");
require(
_newAddressesToWhitelist.length > 0,
"whitelistAddresses: Addresses array is empty."
);
for (uint i=0; i < _newAddressesToWhitelist.length; i++) {
if(!projectIdToWhitelistedAddress[_projectId][_newAddressesToWhitelist[i]]){
projectIdToWhitelistedAddress[_projectId][_newAddressesToWhitelist[i]] = true;
projectIdToWhitelistedArray[_projectId].push(_newAddressesToWhitelist[i]);
}
}
}
function getWhitelistedAddressesForProject(
uint256 _projectId
) external view returns(address[] memory){
require(msg.sender == owner, "getWhitelistedAddressesForProject: Caller is not the owner");
return projectIdToWhitelistedArray[_projectId];
}
function isAddressWhitelisted(
uint256 _projectId,
address _address
) external view returns(bool){
require(_projectId < projects.length, "isAddressWhitelisted: Invalid project ID.");
return projectIdToWhitelistedAddress[_projectId][_address];
}
function getTotalStakingInfoForProjectPerPool(
uint256 _projectId,
uint256 _poolId,
uint256 _pageNumber,
uint256 _pageSize
)external view returns (UserInfo[] memory){
require(msg.sender == owner, "getTotalStakingInfoForProjectPerPool: Caller is not the owner.");
require(
_projectId < projects.length,
"getTotalStakingInfoForProjectPerPool: Invalid project ID."
);
require(
_poolId < projects[_projectId].numberOfPools,
"getTotalStakingInfoForProjectPerPool: Invalid pool ID."
);
uint256 _usersStakedInPool = stakingPoolInfo[_projectId][_poolId].usersStaked.length;
require(
_usersStakedInPool > 0,
"getTotalStakingInfoForProjectPerPool: Nobody staked in this pool."
);
require(
_pageSize > 0,
"getTotalStakingInfoForProjectPerPool: Invalid page size."
);
require(
_pageNumber > 0,
"getTotalStakingInfoForProjectPerPool: Invalid page number."
);
uint256 _startIndex = _pageNumber.sub(1).mul(_pageSize);
if(_pageNumber > 1){
require(
_startIndex < _usersStakedInPool,
"getTotalStakingInfoForProjectPerPool: Specified parameters exceed number of users in the pool."
);
}
uint256 _endIndex = _pageNumber.mul(_pageSize);
if(_endIndex > _usersStakedInPool){
_endIndex = _usersStakedInPool;
}
UserInfo[] memory _result = new UserInfo[](_endIndex.sub(_startIndex));
uint256 _resultIndex = 0;
for(uint256 i=_startIndex; i < _endIndex; i++){
UserInfo memory _userInfo;
_userInfo.userAddress = stakingPoolInfo[_projectId][_poolId].usersStaked[i];
_userInfo.poolId = _poolId;
_userInfo.percentageOfTokensStakedInPool
= getPercentageAmountStakedByUserInPool(_projectId,_poolId,_userInfo.userAddress);
_userInfo.amountOfTokensStakedInPool
= getAmountStakedByUserInPool(_projectId,_poolId,_userInfo.userAddress);
_result[_resultIndex]=_userInfo;
_resultIndex = _resultIndex + 1;
}
return _result;
}
function numberOfProjects() external view returns (uint256) {
return projects.length;
}
function numberOfPools(uint256 _projectId) external view returns (uint256) {
require(_projectId < projects.length, "numberOfPools: Invalid project ID.");
return projects[_projectId].numberOfPools;
}
function getTotalAmountStakedInProject(uint256 _projectId) external view returns (uint256) {
require(
_projectId < projects.length,
"getTotalAmountStakedInProject: Invalid project ID."
);
return projects[_projectId].totalAmountStaked;
}
function getTotalAmountStakedInPool(
uint256 _projectId,
uint256 _poolId
) external view returns (uint256) {
require(_projectId < projects.length, "getTotalAmountStakedInPool: Invalid project ID.");
require(
_poolId < projects[_projectId].numberOfPools,
"getTotalAmountStakedInPool: Invalid pool ID."
);
return stakingPoolInfo[_projectId][_poolId].totalAmountStaked;
}
function getAmountStakedByUserInPool(
uint256 _projectId,
uint256 _poolId,
address _address
) public view returns (uint256) {
require(_projectId < projects.length, "getAmountStakedByUserInPool: Invalid project ID.");
require(
_poolId < projects[_projectId].numberOfPools,
"getAmountStakedByUserInPool: Invalid pool ID."
);
return userStakedAmount[_projectId][_poolId][_address];
}
function getPercentageAmountStakedByUserInPool(
uint256 _projectId,
uint256 _poolId,
address _address
) public view returns (uint256) {
require(
_projectId < projects.length,
"getPercentageAmountStakedByUserInPool: Invalid project ID."
);
require(
_poolId < projects[_projectId].numberOfPools,
"getPercentageAmountStakedByUserInPool: Invalid pool ID."
);
return userStakedAmount[_projectId][_poolId][_address]
.mul(1e8)
.div(stakingPoolInfo[_projectId][_poolId]
.totalAmountStaked);
}
} | @notice ProjectID => WhitelistedArray | mapping(uint256 => address[]) private projectIdToWhitelistedArray;
| 6,598,705 | [
1,
4109,
734,
516,
3497,
7523,
329,
1076,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
2874,
12,
11890,
5034,
516,
1758,
63,
5717,
3238,
9882,
774,
18927,
329,
1076,
31,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0x43f4e0cd4d9f90bb14c2bB4d1eeBa471B428AFAb/sources/arbitrage/FlashBot.sol | do not use safe transfer here to prevents revert by any shitty token | function withdraw() external {
uint256 balance = address(this).balance;
if (balance > 0) {
payable(owner()).transfer(balance);
emit Withdrawn(owner(), balance);
}
for (uint256 i = 0; i < baseTokens.length(); i++) {
address token = baseTokens.at(i);
balance = IERC20(token).balanceOf(address(this));
if (balance > 0) {
IERC20(token).transfer(owner(), balance);
}
}
}
| 4,861,683 | [
1,
2896,
486,
999,
4183,
7412,
2674,
358,
17793,
15226,
635,
1281,
699,
305,
4098,
1147,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
598,
9446,
1435,
3903,
288,
203,
3639,
2254,
5034,
11013,
273,
1758,
12,
2211,
2934,
12296,
31,
203,
3639,
309,
261,
12296,
405,
374,
13,
288,
203,
5411,
8843,
429,
12,
8443,
1435,
2934,
13866,
12,
12296,
1769,
203,
5411,
3626,
3423,
9446,
82,
12,
8443,
9334,
11013,
1769,
203,
3639,
289,
203,
203,
3639,
364,
261,
11890,
5034,
277,
273,
374,
31,
277,
411,
1026,
5157,
18,
2469,
5621,
277,
27245,
288,
203,
5411,
1758,
1147,
273,
1026,
5157,
18,
270,
12,
77,
1769,
203,
5411,
11013,
273,
467,
654,
39,
3462,
12,
2316,
2934,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
5411,
309,
261,
12296,
405,
374,
13,
288,
203,
7734,
467,
654,
39,
3462,
12,
2316,
2934,
13866,
12,
8443,
9334,
11013,
1769,
203,
5411,
289,
203,
3639,
289,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
//Address: 0x2df0e612dad9ffe8141b3987f60608742db2feca
//Contract name: StableICO
//Balance: 0 Ether
//Verification Date: 9/2/2017
//Transacion Count: 38
// CODE STARTS HERE
pragma solidity ^0.4.11;
/// @title STABLE Project ICO
/// @author Konrad Szałapak <[email protected]>
/*
* Ownable
*
* Base contract with an owner.
* Provides onlyOwner modifier, which prevents function from running if it is called by anyone other than the owner.
*/
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
}
/* New ERC23 contract interface */
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function totalSupply() constant returns (uint256 _supply);
function transfer(address to, uint value) returns (bool ok);
function transfer(address to, uint value, bytes data) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
/*
* Contract that is working with ERC223 tokens
*/
contract ContractReceiver {
function tokenFallback(address _from, uint _value, bytes _data);
}
/**
* ERC23 token by Dexaran
*
* https://github.com/Dexaran/ERC23-tokens
*/
/* https://github.com/LykkeCity/EthereumApiDotNetCore/blob/master/src/ContractBuilder/contracts/token/SafeMath.sol */
contract SafeMath {
uint256 constant public MAX_UINT256 =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
function safeAdd(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (x > MAX_UINT256 - y) throw;
return x + y;
}
function safeSub(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (x < y) throw;
return x - y;
}
function safeMul(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (y == 0) return 0;
if (x > MAX_UINT256 / y) throw;
return x * y;
}
}
/**
* STABLE Awareness Token - STA
*/
contract ERC223Token_STA is ERC223, SafeMath, Ownable {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping(address => uint) balances;
// stable params:
uint256 public icoEndBlock; // last block number of ICO
uint256 public maxSupply; // maximum token supply
uint256 public minedTokenCount; // counter of mined tokens
address public icoAddress; // address of ICO contract
uint256 private multiplier; // for managing token fractionals
struct Miner { // struct for mined tokens data
uint256 block;
address minerAddress;
}
mapping (uint256 => Miner) public minedTokens; // mined tokens data
event MessageClaimMiningReward(address indexed miner, uint256 block, uint256 sta); // notifies clients about sta winning miner
event Burn(address indexed from, uint256 value); // notifies clients about the amount burnt
function ERC223Token_STA() {
decimals = 8;
multiplier = 10**uint256(decimals);
maxSupply = 10000000000; // Maximum possible supply == 100 STA
name = "STABLE STA Token"; // Set the name for display purposes
symbol = "STA"; // Set the symbol for display purposes
icoEndBlock = 4332000; // INIT // last block number for ICO
totalSupply = 0; // Update total supply
// balances[msg.sender] = totalSupply; // Give the creator all initial tokens
}
// trigger rewarding a miner with STA token:
function claimMiningReward() {
if (icoAddress == address(0)) throw; // ICO address must be set up first
if (msg.sender != icoAddress && msg.sender != owner) throw; // triggering enabled only for ICO or owner
if (block.number > icoEndBlock) throw; // rewarding enabled only before the end of ICO
if (minedTokenCount * multiplier >= maxSupply) throw;
if (minedTokenCount > 0) {
for (uint256 i = 0; i < minedTokenCount; i++) {
if (minedTokens[i].block == block.number) throw;
}
}
totalSupply += 1 * multiplier;
balances[block.coinbase] += 1 * multiplier; // reward miner with one STA token
minedTokens[minedTokenCount] = Miner(block.number, block.coinbase);
minedTokenCount += 1;
MessageClaimMiningReward(block.coinbase, block.number, 1 * multiplier);
}
function selfDestroy() onlyOwner {
// allow to suicide STA token after around 2 weeks (25s/block) from the end of ICO
if (block.number <= icoEndBlock+14*3456) throw;
suicide(this);
}
// /stable params
// Function to access name of token .
function name() constant returns (string _name) {
return name;
}
// Function to access symbol of token .
function symbol() constant returns (string _symbol) {
return symbol;
}
// Function to access decimals of token .
function decimals() constant returns (uint8 _decimals) {
return decimals;
}
// Function to access total supply of tokens .
function totalSupply() constant returns (uint256 _totalSupply) {
return totalSupply;
}
function minedTokenCount() constant returns (uint256 _minedTokenCount) {
return minedTokenCount;
}
function icoAddress() constant returns (address _icoAddress) {
return icoAddress;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) returns (bool success) {
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
transferToContract(_to, _value, empty);
}
else {
transferToAddress(_to, _value, empty);
}
return true;
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private returns (bool is_contract) {
uint length;
_addr = _addr; // workaround for Mist's inability to compile
is_contract = is_contract; // workaround for Mist's inability to compile
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
//function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) throw;
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) throw;
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function burn(address _address, uint256 _value) returns (bool success) {
if (icoAddress == address(0)) throw;
if (msg.sender != owner && msg.sender != icoAddress) throw; // only owner and ico contract are allowed
if (balances[_address] < _value) throw; // Check if the sender has enough tokens
balances[_address] -= _value; // Subtract from the sender
totalSupply -= _value;
Burn(_address, _value);
return true;
}
/* setting ICO address for allowing execution from the ICO contract */
function setIcoAddress(address _address) onlyOwner {
if (icoAddress == address(0)) {
icoAddress = _address;
}
else throw;
}
}
/**
* Stable Token - STB
*/
contract ERC223Token_STB is ERC223, SafeMath, Ownable {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping(address => uint) balances;
// stable params:
uint256 public maxSupply;
uint256 public icoEndBlock;
address public icoAddress;
function ERC223Token_STB() {
totalSupply = 0; // Update total supply
maxSupply = 1000000000000; // Maximum possible supply of STB == 100M STB
name = "STABLE STB Token"; // Set the name for display purposes
decimals = 4; // Amount of decimals for display purposes
symbol = "STB"; // Set the symbol for display purposes
icoEndBlock = 4332000; // INIT // last block number of ICO
//balances[msg.sender] = totalSupply; // Give the creator all initial tokens
}
// Function to access max supply of tokens .
function maxSupply() constant returns (uint256 _maxSupply) {
return maxSupply;
}
// /stable params
// Function to access name of token .
function name() constant returns (string _name) {
return name;
}
// Function to access symbol of token .
function symbol() constant returns (string _symbol) {
return symbol;
}
// Function to access decimals of token .
function decimals() constant returns (uint8 _decimals) {
return decimals;
}
// Function to access total supply of tokens .
function totalSupply() constant returns (uint256 _totalSupply) {
return totalSupply;
}
function icoAddress() constant returns (address _icoAddress) {
return icoAddress;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) returns (bool success) {
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
transferToContract(_to, _value, empty);
}
else {
transferToAddress(_to, _value, empty);
}
return true;
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private returns (bool is_contract) {
uint length;
_addr = _addr; // workaround for Mist's inability to compile
is_contract = is_contract; // workaround for Mist's inability to compile
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
//function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) throw;
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) throw;
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
/* setting ICO address for allowing execution from the ICO contract */
function setIcoAddress(address _address) onlyOwner {
if (icoAddress == address(0)) {
icoAddress = _address;
}
else throw;
}
/* mint new tokens */
function mint(address _receiver, uint256 _amount) {
if (icoAddress == address(0)) throw;
if (msg.sender != icoAddress && msg.sender != owner) throw; // mint allowed only for ICO contract or owner
if (safeAdd(totalSupply, _amount) > maxSupply) throw;
totalSupply = safeAdd(totalSupply, _amount);
balances[_receiver] = safeAdd(balances[_receiver], _amount);
Transfer(0, _receiver, _amount, new bytes(0));
}
}
/* main contract - ICO */
contract StableICO is Ownable, SafeMath {
uint256 public crowdfundingTarget; // ICO target, in wei
ERC223Token_STA public sta; // address of STA token
ERC223Token_STB public stb; // address of STB token
address public beneficiary; // where the donation is transferred after successful ICO
uint256 public icoStartBlock; // number of start block of ICO
uint256 public icoEndBlock; // number of end block of ICO
bool public isIcoFinished; // boolean for ICO status - is ICO finished?
bool public isIcoSucceeded; // boolean for ICO status - is crowdfunding target reached?
bool public isDonatedEthTransferred; // boolean for ICO status - is donation transferred to the secure account?
bool public isStbMintedForStaEx; // boolean for ICO status - is extra STB tokens minted for covering exchange of STA token?
uint256 public receivedStaAmount; // amount of received STA tokens from rewarded miners
uint256 public totalFunded; // amount of ETH donations
uint256 public ownersEth; // amount of ETH transferred to ICO contract by the owner
uint256 public oneStaIsStb; // one STA value in STB
struct Donor { // struct for ETH donations
address donorAddress;
uint256 ethAmount;
uint256 block;
bool exchangedOrRefunded;
uint256 stbAmount;
}
mapping (uint256 => Donor) public donations; // storage for ETH donations
uint256 public donationNum; // counter of ETH donations
struct Miner { // struct for received STA tokens
address minerAddress;
uint256 staAmount;
uint256 block;
bool exchanged;
uint256 stbAmount;
}
mapping (uint256 => Miner) public receivedSta; // storage for received STA tokens
uint256 public minerNum; // counter of STA receives
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event MessageExchangeEthStb(address from, uint256 eth, uint256 stb);
event MessageExchangeStaStb(address from, uint256 sta, uint256 stb);
event MessageReceiveEth(address from, uint256 eth, uint256 block);
event MessageReceiveSta(address from, uint256 sta, uint256 block);
event MessageReceiveStb(address from, uint256 stb, uint256 block, bytes data); // it should never happen
event MessageRefundEth(address donor_address, uint256 eth);
/* constructor */
function StableICO() {
crowdfundingTarget = 750000000000000000000; // INIT
sta = ERC223Token_STA(0x164489AB676C578bED0515dDCF92Ef37aacF9a29); // INIT
stb = ERC223Token_STB(0x09bca6ebab05ee2ae945be4eda51393d94bf7b99); // INIT
beneficiary = 0xb2e7579f84a8ddafdb376f9872916b7fcb8dbec0; // INIT
icoStartBlock = 4232000; // INIT
icoEndBlock = 4332000; // INIT
}
/* trigger rewarding the miner with STA token */
function claimMiningReward() public onlyOwner {
sta.claimMiningReward();
}
/* Receiving STA from miners - during and after ICO */
function tokenFallback(address _from, uint256 _value, bytes _data) {
if (block.number < icoStartBlock) throw;
if (msg.sender == address(sta)) {
if (_value < 50000000) throw; // minimum 0.5 STA
if (block.number < icoEndBlock+14*3456) { // allow STA tokens exchange for around 14 days (25s/block) after ICO
receivedSta[minerNum] = Miner(_from, _value, block.number, false, 0);
minerNum += 1;
receivedStaAmount = safeAdd(receivedStaAmount, _value);
MessageReceiveSta(_from, _value, block.number);
} else throw;
} else if(msg.sender == address(stb)) {
MessageReceiveStb(_from, _value, block.number, _data);
} else {
throw; // other tokens
}
}
/* Receiving ETH */
function () payable {
if (msg.value < 100000000000000000) throw; // minimum 0.1 ETH
// before ICO (pre-ico)
if (block.number < icoStartBlock) {
if (msg.sender == owner) {
ownersEth = safeAdd(ownersEth, msg.value);
} else {
totalFunded = safeAdd(totalFunded, msg.value);
donations[donationNum] = Donor(msg.sender, msg.value, block.number, false, 0);
donationNum += 1;
MessageReceiveEth(msg.sender, msg.value, block.number);
}
}
// during ICO
else if (block.number >= icoStartBlock && block.number <= icoEndBlock) {
if (msg.sender != owner) {
totalFunded = safeAdd(totalFunded, msg.value);
donations[donationNum] = Donor(msg.sender, msg.value, block.number, false, 0);
donationNum += 1;
MessageReceiveEth(msg.sender, msg.value, block.number);
} else ownersEth = safeAdd(ownersEth, msg.value);
}
// after ICO - first ETH transfer is returned to the sender
else if (block.number > icoEndBlock) {
if (!isIcoFinished) {
isIcoFinished = true;
msg.sender.transfer(msg.value); // return ETH to the sender
if (totalFunded >= crowdfundingTarget) {
isIcoSucceeded = true;
exchangeStaStb(0, minerNum);
exchangeEthStb(0, donationNum);
drawdown();
} else {
refund(0, donationNum);
}
} else {
if (msg.sender != owner) throw; // WARNING: senders ETH may be lost (if transferred after finished ICO)
ownersEth = safeAdd(ownersEth, msg.value);
}
} else {
throw; // WARNING: senders ETH may be lost (if transferred after finished ICO)
}
}
/* send STB to the miners who returned STA tokens - after successful ICO */
function exchangeStaStb(uint256 _from, uint256 _to) private {
if (!isIcoSucceeded) throw;
if (_from >= _to) return; // skip the function if there is invalid range given for loop
uint256 _sta2stb = 10**4;
uint256 _wei2stb = 10**14;
if (!isStbMintedForStaEx) {
uint256 _mintAmount = (10*totalFunded)*5/1000 / _wei2stb; // 0.5% extra STB minting for STA covering
oneStaIsStb = _mintAmount / 100;
stb.mint(address(this), _mintAmount);
isStbMintedForStaEx = true;
}
/* exchange */
uint256 _toBurn = 0;
for (uint256 i = _from; i < _to; i++) {
if (receivedSta[i].exchanged) continue; // skip already exchanged STA
stb.transfer(receivedSta[i].minerAddress, receivedSta[i].staAmount/_sta2stb * oneStaIsStb / 10**4);
receivedSta[i].exchanged = true;
receivedSta[i].stbAmount = receivedSta[i].staAmount/_sta2stb * oneStaIsStb / 10**4;
_toBurn += receivedSta[i].staAmount;
MessageExchangeStaStb(receivedSta[i].minerAddress, receivedSta[i].staAmount,
receivedSta[i].staAmount/_sta2stb * oneStaIsStb / 10**4);
}
sta.burn(address(this), _toBurn); // burn received and processed STA tokens
}
/* send STB to the donors - after successful ICO */
function exchangeEthStb(uint256 _from, uint256 _to) private {
if (!isIcoSucceeded) throw;
if (_from >= _to) return; // skip the function if there is invalid range given for loop
uint256 _wei2stb = 10**14; // calculate eth to stb exchange
uint _pb = (icoEndBlock - icoStartBlock)/4;
uint _bonus;
/* mint */
uint256 _mintAmount = 0;
for (uint256 i = _from; i < _to; i++) {
if (donations[i].exchangedOrRefunded) continue; // skip already minted STB
if (donations[i].block < icoStartBlock + _pb) _bonus = 6; // first period; bonus in %
else if (donations[i].block >= icoStartBlock + _pb && donations[i].block < icoStartBlock + 2*_pb) _bonus = 4; // 2nd
else if (donations[i].block >= icoStartBlock + 2*_pb && donations[i].block < icoStartBlock + 3*_pb) _bonus = 2; // 3rd
else _bonus = 0; // 4th
_mintAmount += 10 * ( (100 + _bonus) * (donations[i].ethAmount / _wei2stb) / 100);
}
stb.mint(address(this), _mintAmount);
/* exchange */
for (i = _from; i < _to; i++) {
if (donations[i].exchangedOrRefunded) continue; // skip already exchanged ETH
if (donations[i].block < icoStartBlock + _pb) _bonus = 6; // first period; bonus in %
else if (donations[i].block >= icoStartBlock + _pb && donations[i].block < icoStartBlock + 2*_pb) _bonus = 4; // 2nd
else if (donations[i].block >= icoStartBlock + 2*_pb && donations[i].block < icoStartBlock + 3*_pb) _bonus = 2; // 3rd
else _bonus = 0; // 4th
stb.transfer(donations[i].donorAddress, 10 * ( (100 + _bonus) * (donations[i].ethAmount / _wei2stb) / 100) );
donations[i].exchangedOrRefunded = true;
donations[i].stbAmount = 10 * ( (100 + _bonus) * (donations[i].ethAmount / _wei2stb) / 100);
MessageExchangeEthStb(donations[i].donorAddress, donations[i].ethAmount,
10 * ( (100 + _bonus) * (donations[i].ethAmount / _wei2stb) / 100));
}
}
// send funds to the ICO beneficiary account - after successful ICO
function drawdown() private {
if (!isIcoSucceeded || isDonatedEthTransferred) throw;
beneficiary.transfer(totalFunded);
isDonatedEthTransferred = true;
}
/* refund ETH - after unsuccessful ICO */
function refund(uint256 _from, uint256 _to) private {
if (!isIcoFinished || isIcoSucceeded) throw;
if (_from >= _to) return;
for (uint256 i = _from; i < _to; i++) {
if (donations[i].exchangedOrRefunded) continue;
donations[i].donorAddress.transfer(donations[i].ethAmount);
donations[i].exchangedOrRefunded = true;
MessageRefundEth(donations[i].donorAddress, donations[i].ethAmount);
}
}
// send owner's funds to the ICO owner - after ICO
function transferEthToOwner(uint256 _amount) public onlyOwner {
if (!isIcoFinished || _amount <= 0 || _amount > ownersEth) throw;
owner.transfer(_amount);
ownersEth -= _amount;
}
// send STB to the ICO owner - after ICO
function transferStbToOwner(uint256 _amount) public onlyOwner {
if (!isIcoFinished || _amount <= 0) throw;
stb.transfer(owner, _amount);
}
/* backup functions to be executed "manually" - in case of a critical ethereum platform failure
during automatic function execution */
function backup_finishIcoVars() public onlyOwner {
if (block.number <= icoEndBlock || isIcoFinished) throw;
isIcoFinished = true;
if (totalFunded >= crowdfundingTarget) isIcoSucceeded = true;
}
function backup_exchangeStaStb(uint256 _from, uint256 _to) public onlyOwner {
exchangeStaStb(_from, _to);
}
function backup_exchangeEthStb(uint256 _from, uint256 _to) public onlyOwner {
exchangeEthStb(_from, _to);
}
function backup_drawdown() public onlyOwner {
drawdown();
}
function backup_drawdown_amount(uint256 _amount) public onlyOwner {
if (!isIcoSucceeded) throw;
beneficiary.transfer(_amount);
}
function backup_refund(uint256 _from, uint256 _to) public onlyOwner {
refund(_from, _to);
}
/* /backup */
}
| skip already minted STB
| if (donations[i].exchangedOrRefunded) continue; | 12,620,563 | [
1,
7457,
1818,
312,
474,
329,
2347,
38,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
5411,
309,
261,
19752,
1012,
63,
77,
8009,
338,
6703,
1162,
1957,
12254,
13,
1324,
31,
282,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/4/0xbc3155a83686b5063d57EBa58E31d94fB0EaF124/sources/browser/hook.sol | deduct in multiple of 35
| if(i > 2) tmp2 = (2**(_planIndex +1)) * levelBuyPrice[0] * prcnt[i+5] / 100000000; | 656,273 | [
1,
785,
853,
316,
3229,
434,
13191,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
5411,
309,
12,
77,
405,
576,
13,
1853,
22,
273,
261,
22,
636,
24899,
7088,
1016,
397,
21,
3719,
380,
1801,
38,
9835,
5147,
63,
20,
65,
380,
846,
13085,
63,
77,
15,
25,
65,
342,
2130,
9449,
31,
282,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
import "../../savings/dydx/ISoloMargin.sol";
import "../../utils/SafeERC20.sol";
import "../../interfaces/TokenInterface.sol";
import "../../DS/DSProxy.sol";
import "../AaveHelper.sol";
import "../../auth/AdminAuth.sol";
// weth->eth
// deposit eth for users proxy
// borrow users token from proxy
// repay on behalf of user
// pull user supply
// take eth amount from supply (if needed more, borrow it?)
// return eth to sender
/// @title Import Aave position from account to wallet
contract AaveImport is AaveHelper, AdminAuth {
using SafeERC20 for ERC20;
address public constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address public constant BASIC_PROXY = 0xF499FB2feb3351aEA373723a6A0e8F6BE6fBF616;
address public constant AETH_ADDRESS = 0x3a3A65aAb0dd2A17E3F1947bA16138cd37d08c04;
function callFunction(
address sender,
Account.Info memory account,
bytes memory data
) public {
(
address collateralToken,
address borrowToken,
uint256 ethAmount,
address user,
address proxy
)
= abi.decode(data, (address,address,uint256,address,address));
// withdraw eth
TokenInterface(WETH_ADDRESS).withdraw(ethAmount);
address lendingPoolCoreAddress = ILendingPoolAddressesProvider(AAVE_LENDING_POOL_ADDRESSES).getLendingPoolCore();
address lendingPool = ILendingPoolAddressesProvider(AAVE_LENDING_POOL_ADDRESSES).getLendingPool();
address aCollateralToken = ILendingPool(lendingPoolCoreAddress).getReserveATokenAddress(collateralToken);
address aBorrowToken = ILendingPool(lendingPoolCoreAddress).getReserveATokenAddress(borrowToken);
uint256 globalBorrowAmount = 0;
{ // avoid stack too deep
// deposit eth on behalf of proxy
DSProxy(payable(proxy)).execute{value: ethAmount}(BASIC_PROXY, abi.encodeWithSignature("deposit(address,uint256)", ETH_ADDR, ethAmount));
// borrow needed amount to repay users borrow
(,uint256 borrowAmount,,uint256 borrowRateMode,,,uint256 originationFee,,,) = ILendingPool(lendingPool).getUserReserveData(borrowToken, user);
borrowAmount += originationFee;
DSProxy(payable(proxy)).execute(BASIC_PROXY, abi.encodeWithSignature("borrow(address,uint256,uint256)", borrowToken, borrowAmount, borrowRateMode));
globalBorrowAmount = borrowAmount;
}
// payback on behalf of user
if (borrowToken != ETH_ADDR) {
ERC20(borrowToken).safeApprove(proxy, globalBorrowAmount);
DSProxy(payable(proxy)).execute(BASIC_PROXY, abi.encodeWithSignature("paybackOnBehalf(address,address,uint256,bool,address)", borrowToken, aBorrowToken, 0, true, user));
} else {
DSProxy(payable(proxy)).execute{value: globalBorrowAmount}(BASIC_PROXY, abi.encodeWithSignature("paybackOnBehalf(address,address,uint256,bool,address)", borrowToken, aBorrowToken, 0, true, user));
}
// pull tokens from user to proxy
ERC20(aCollateralToken).safeTransferFrom(user, proxy, ERC20(aCollateralToken).balanceOf(user));
// enable as collateral
DSProxy(payable(proxy)).execute(BASIC_PROXY, abi.encodeWithSignature("setUserUseReserveAsCollateralIfNeeded(address)", collateralToken));
// withdraw deposited eth
DSProxy(payable(proxy)).execute(BASIC_PROXY, abi.encodeWithSignature("withdraw(address,address,uint256,bool)", ETH_ADDR, AETH_ADDRESS, ethAmount, false));
// deposit eth, get weth and return to sender
TokenInterface(WETH_ADDRESS).deposit.value(address(this).balance)();
ERC20(WETH_ADDRESS).safeTransfer(proxy, ethAmount+2);
}
/// @dev if contract receive eth, convert it to WETH
receive() external payable {
// deposit eth and get weth
if (msg.sender == owner) {
TokenInterface(WETH_ADDRESS).deposit.value(address(this).balance)();
}
}
} | withdraw eth deposit eth on behalf of proxy borrow needed amount to repay users borrow | ) public {
(
address collateralToken,
address borrowToken,
uint256 ethAmount,
address user,
address proxy
)
= abi.decode(data, (address,address,uint256,address,address));
TokenInterface(WETH_ADDRESS).withdraw(ethAmount);
address lendingPoolCoreAddress = ILendingPoolAddressesProvider(AAVE_LENDING_POOL_ADDRESSES).getLendingPoolCore();
address lendingPool = ILendingPoolAddressesProvider(AAVE_LENDING_POOL_ADDRESSES).getLendingPool();
address aCollateralToken = ILendingPool(lendingPoolCoreAddress).getReserveATokenAddress(collateralToken);
address aBorrowToken = ILendingPool(lendingPoolCoreAddress).getReserveATokenAddress(borrowToken);
uint256 globalBorrowAmount = 0;
(,uint256 borrowAmount,,uint256 borrowRateMode,,,uint256 originationFee,,,) = ILendingPool(lendingPool).getUserReserveData(borrowToken, user);
borrowAmount += originationFee;
DSProxy(payable(proxy)).execute(BASIC_PROXY, abi.encodeWithSignature("borrow(address,uint256,uint256)", borrowToken, borrowAmount, borrowRateMode));
globalBorrowAmount = borrowAmount;
}
| 1,821,637 | [
1,
1918,
9446,
13750,
443,
1724,
13750,
603,
12433,
6186,
434,
2889,
29759,
3577,
3844,
358,
2071,
528,
3677,
29759,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
262,
1071,
288,
203,
203,
3639,
261,
203,
5411,
1758,
4508,
2045,
287,
1345,
16,
203,
5411,
1758,
29759,
1345,
16,
203,
5411,
2254,
5034,
13750,
6275,
16,
203,
5411,
1758,
729,
16,
203,
5411,
1758,
2889,
203,
3639,
262,
203,
3639,
273,
24126,
18,
3922,
12,
892,
16,
261,
2867,
16,
2867,
16,
11890,
5034,
16,
2867,
16,
2867,
10019,
203,
203,
3639,
29938,
12,
59,
1584,
44,
67,
15140,
2934,
1918,
9446,
12,
546,
6275,
1769,
203,
203,
3639,
1758,
328,
2846,
2864,
4670,
1887,
273,
467,
48,
2846,
2864,
7148,
2249,
12,
5284,
3412,
67,
900,
2908,
1360,
67,
20339,
67,
8355,
7031,
1090,
55,
2934,
588,
48,
2846,
2864,
4670,
5621,
203,
3639,
1758,
328,
2846,
2864,
273,
467,
48,
2846,
2864,
7148,
2249,
12,
5284,
3412,
67,
900,
2908,
1360,
67,
20339,
67,
8355,
7031,
1090,
55,
2934,
588,
48,
2846,
2864,
5621,
203,
3639,
1758,
279,
13535,
2045,
287,
1345,
273,
467,
48,
2846,
2864,
12,
80,
2846,
2864,
4670,
1887,
2934,
588,
607,
6527,
789,
969,
1887,
12,
12910,
2045,
287,
1345,
1769,
203,
3639,
1758,
279,
38,
15318,
1345,
273,
467,
48,
2846,
2864,
12,
80,
2846,
2864,
4670,
1887,
2934,
588,
607,
6527,
789,
969,
1887,
12,
70,
15318,
1345,
1769,
203,
3639,
2254,
5034,
2552,
38,
15318,
6275,
273,
374,
31,
203,
203,
5411,
261,
16,
11890,
5034,
29759,
6275,
16408,
11890,
5034,
29759,
4727,
2309,
16408,
16,
11890,
5034,
1647,
1735,
14667,
16408,
16,
13,
273,
467,
48,
2846,
2864,
12,
80,
2
]
|
./partial_match/1/0xd8c44D106B84b4fFD7ECf9a20e9183C017c5F221/sources/TLAMB.sol | lambmap[msg.sender] = _remarks; | function transferRemarks(address _to, uint256 _value,bytes32 _remarks) public whenNotPaused returns (bool) {
bool result = transfer(_to,_value);
require(result == true);
emit TransferRemarks(msg.sender, _to, _value,_remarks);
return result;
}
| 2,615,237 | [
1,
80,
2536,
1458,
63,
3576,
18,
15330,
65,
273,
389,
2764,
27943,
31,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
7412,
1933,
27943,
12,
2867,
389,
869,
16,
2254,
5034,
389,
1132,
16,
3890,
1578,
389,
2764,
27943,
13,
1071,
1347,
1248,
28590,
1135,
261,
6430,
13,
288,
203,
565,
1426,
563,
273,
7412,
24899,
869,
16,
67,
1132,
1769,
203,
565,
2583,
12,
2088,
422,
638,
1769,
203,
565,
3626,
12279,
1933,
27943,
12,
3576,
18,
15330,
16,
389,
869,
16,
389,
1132,
16,
67,
2764,
27943,
1769,
203,
565,
327,
563,
31,
203,
225,
289,
203,
21281,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
/**
*Submitted for verification at Etherscan.io on 2019-12-03
*/
pragma solidity 0.5.13;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c ; //inject UNINIT LOCAL/STATE VAR
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c ; //inject UNINIT LOCAL/STATE VAR
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c ; //inject UNINIT LOCAL/STATE VAR
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c ; //inject UNINIT LOCAL/STATE VAR
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20Mintable}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See {_burn} and {_approve}.
*/
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract GlobalsAndUtility is ERC20 {
/* XfLobbyEnter (auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
address indexed memberAddr
uint256 indexed entryId
uint96 rawAmount --> data0 [135: 40]
address indexed referrerAddr
*/
event XfLobbyEnter(
uint256 data0,
address indexed memberAddr,
uint256 indexed entryId,
address indexed referrerAddr
);
/* XfLobbyExit (auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
address indexed memberAddr
uint256 indexed entryId
uint72 xfAmount --> data0 [111: 40]
address indexed referrerAddr
*/
event XfLobbyExit(
uint256 data0,
address indexed memberAddr,
uint256 indexed entryId,
address indexed referrerAddr
);
/* DailyDataUpdate (auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
uint16 beginDay --> data0 [ 55: 40]
uint16 endDay --> data0 [ 71: 56]
bool isAutoUpdate --> data0 [ 79: 72]
address indexed updaterAddr
*/
event DailyDataUpdate(
uint256 data0,
address indexed updaterAddr
);
/* Claim (auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
bytes20 indexed btcAddr
uint56 rawSatoshis --> data0 [ 95: 40]
uint56 adjSatoshis --> data0 [151: 96]
address indexed claimToAddr
uint8 claimFlags --> data0 [159:152]
uint72 claimedHearts --> data0 [231:160]
address indexed referrerAddr
address senderAddr --> data1 [159: 0]
*/
event Claim(
uint256 data0,
uint256 data1,
bytes20 indexed btcAddr,
address indexed claimToAddr,
address indexed referrerAddr
);
/* ClaimAssist (auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
bytes20 btcAddr --> data0 [199: 40]
uint56 rawSatoshis --> data0 [255:200]
uint56 adjSatoshis --> data1 [ 55: 0]
address claimToAddr --> data1 [215: 56]
uint8 claimFlags --> data1 [223:216]
uint72 claimedHearts --> data2 [ 71: 0]
address referrerAddr --> data2 [231: 72]
address indexed senderAddr
*/
event ClaimAssist(
uint256 data0,
uint256 data1,
uint256 data2,
address indexed senderAddr
);
/* StakeStart (auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
address indexed stakerAddr
uint40 indexed stakeId
uint72 stakedHearts --> data0 [111: 40]
uint72 stakeShares --> data0 [183:112]
uint16 stakedDays --> data0 [199:184]
bool isAutoStake --> data0 [207:200]
*/
event StakeStart(
uint256 data0,
address indexed stakerAddr,
uint40 indexed stakeId
);
/* StakeGoodAccounting(auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
address indexed stakerAddr
uint40 indexed stakeId
uint72 stakedHearts --> data0 [111: 40]
uint72 stakeShares --> data0 [183:112]
uint72 payout --> data0 [255:184]
uint72 penalty --> data1 [ 71: 0]
address indexed senderAddr
*/
event StakeGoodAccounting(
uint256 data0,
uint256 data1,
address indexed stakerAddr,
uint40 indexed stakeId,
address indexed senderAddr
);
/* StakeEnd (auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
address indexed stakerAddr
uint40 indexed stakeId
uint72 stakedHearts --> data0 [111: 40]
uint72 stakeShares --> data0 [183:112]
uint72 payout --> data0 [255:184]
uint72 penalty --> data1 [ 71: 0]
uint16 servedDays --> data1 [ 87: 72]
bool prevUnlocked --> data1 [ 95: 88]
*/
event StakeEnd(
uint256 data0,
uint256 data1,
address indexed stakerAddr,
uint40 indexed stakeId
);
/* ShareRateChange (auto-generated event)
uint40 timestamp --> data0 [ 39: 0]
uint40 shareRate --> data0 [ 79: 40]
uint40 indexed stakeId
*/
event ShareRateChange(
uint256 data0,
uint40 indexed stakeId
);
/* Origin address */
address internal constant ORIGIN_ADDR = 0x9A6a414D6F3497c05E3b1De90520765fA1E07c03;
/* Flush address */
address payable internal constant FLUSH_ADDR = 0x1028132da0B246F5FdDE135fB8B27166766f9c30;
/* ERC20 constants */
string public constant name = "HEX TOKEN";
string public constant symbol = "HEXTKN";
uint8 public constant decimals = 8;
/* Hearts per Satoshi = 10,000 * 1e8 / 1e8 = 1e4 */
uint256 private constant HEARTS_PER_HEX = 10 ** uint256(decimals); // 1e8
uint256 private constant HEX_PER_BTC = 1e4;
uint256 private constant SATOSHIS_PER_BTC = 1e8;
uint256 internal constant HEARTS_PER_SATOSHI = HEARTS_PER_HEX / SATOSHIS_PER_BTC * HEX_PER_BTC;
/* Time of contract launch (2019-12-03T00:00:00Z) */
uint256 internal constant LAUNCH_TIME = 1575331200;
/* Size of a Hearts or Shares uint */
uint256 internal constant HEART_UINT_SIZE = 72;
/* Size of a transform lobby entry index uint */
uint256 internal constant XF_LOBBY_ENTRY_INDEX_SIZE = 40;
uint256 internal constant XF_LOBBY_ENTRY_INDEX_MASK = (1 << XF_LOBBY_ENTRY_INDEX_SIZE) - 1;
/* Seed for WAAS Lobby */
uint256 internal constant WAAS_LOBBY_SEED_HEX = 1e9;
uint256 internal constant WAAS_LOBBY_SEED_HEARTS = WAAS_LOBBY_SEED_HEX * HEARTS_PER_HEX;
/* Start of claim phase */
uint256 internal constant PRE_CLAIM_DAYS = 1;
uint256 internal constant CLAIM_PHASE_START_DAY = PRE_CLAIM_DAYS;
/* Length of claim phase */
uint256 private constant CLAIM_PHASE_WEEKS = 50;
uint256 internal constant CLAIM_PHASE_DAYS = CLAIM_PHASE_WEEKS * 7;
/* End of claim phase */
uint256 internal constant CLAIM_PHASE_END_DAY = CLAIM_PHASE_START_DAY + CLAIM_PHASE_DAYS;
/* Number of words to hold 1 bit for each transform lobby day */
uint256 internal constant XF_LOBBY_DAY_WORDS = (CLAIM_PHASE_END_DAY + 255) >> 8;
/* BigPayDay */
uint256 internal constant BIG_PAY_DAY = CLAIM_PHASE_END_DAY + 1;
/* Root hash of the UTXO Merkle tree */
bytes32 internal constant MERKLE_TREE_ROOT = 0x4e831acb4223b66de3b3d2e54a2edeefb0de3d7916e2886a4b134d9764d41bec;
/* Size of a Satoshi claim uint in a Merkle leaf */
uint256 internal constant MERKLE_LEAF_SATOSHI_SIZE = 45;
/* Zero-fill between BTC address and Satoshis in a Merkle leaf */
uint256 internal constant MERKLE_LEAF_FILL_SIZE = 256 - 160 - MERKLE_LEAF_SATOSHI_SIZE;
uint256 internal constant MERKLE_LEAF_FILL_BASE = (1 << MERKLE_LEAF_FILL_SIZE) - 1;
uint256 internal constant MERKLE_LEAF_FILL_MASK = MERKLE_LEAF_FILL_BASE << MERKLE_LEAF_SATOSHI_SIZE;
/* Size of a Satoshi total uint */
uint256 internal constant SATOSHI_UINT_SIZE = 51;
uint256 internal constant SATOSHI_UINT_MASK = (1 << SATOSHI_UINT_SIZE) - 1;
/* Total Satoshis from all BTC addresses in UTXO snapshot */
uint256 internal constant FULL_SATOSHIS_TOTAL = 1807766732160668;
/* Total Satoshis from supported BTC addresses in UTXO snapshot after applying Silly Whale */
uint256 internal constant CLAIMABLE_SATOSHIS_TOTAL = 910087996911001;
/* Number of claimable BTC addresses in UTXO snapshot */
uint256 internal constant CLAIMABLE_BTC_ADDR_COUNT = 27997742;
/* Largest BTC address Satoshis balance in UTXO snapshot (sanity check) */
uint256 internal constant MAX_BTC_ADDR_BALANCE_SATOSHIS = 25550214098481;
/* Percentage of total claimed Hearts that will be auto-staked from a claim */
uint256 internal constant AUTO_STAKE_CLAIM_PERCENT = 90;
/* Stake timing parameters */
uint256 internal constant MIN_STAKE_DAYS = 1;
uint256 internal constant MIN_AUTO_STAKE_DAYS = 350;
uint256 internal constant MAX_STAKE_DAYS = 5555; // Approx 15 years
uint256 internal constant EARLY_PENALTY_MIN_DAYS = 90;
uint256 private constant LATE_PENALTY_GRACE_WEEKS = 2;
uint256 internal constant LATE_PENALTY_GRACE_DAYS = LATE_PENALTY_GRACE_WEEKS * 7;
uint256 private constant LATE_PENALTY_SCALE_WEEKS = 100;
uint256 internal constant LATE_PENALTY_SCALE_DAYS = LATE_PENALTY_SCALE_WEEKS * 7;
/* Stake shares Longer Pays Better bonus constants used by _stakeStartBonusHearts() */
uint256 private constant LPB_BONUS_PERCENT = 20;
uint256 private constant LPB_BONUS_MAX_PERCENT = 200;
uint256 internal constant LPB = 364 * 100 / LPB_BONUS_PERCENT;
uint256 internal constant LPB_MAX_DAYS = LPB * LPB_BONUS_MAX_PERCENT / 100;
/* Stake shares Bigger Pays Better bonus constants used by _stakeStartBonusHearts() */
uint256 private constant BPB_BONUS_PERCENT = 10;
uint256 private constant BPB_MAX_HEX = 150 * 1e6;
uint256 internal constant BPB_MAX_HEARTS = BPB_MAX_HEX * HEARTS_PER_HEX;
uint256 internal constant BPB = BPB_MAX_HEARTS * 100 / BPB_BONUS_PERCENT;
/* Share rate is scaled to increase precision */
uint256 internal constant SHARE_RATE_SCALE = 1e5;
/* Share rate max (after scaling) */
uint256 internal constant SHARE_RATE_UINT_SIZE = 40;
uint256 internal constant SHARE_RATE_MAX = (1 << SHARE_RATE_UINT_SIZE) - 1;
/* Constants for preparing the claim message text */
uint8 internal constant ETH_ADDRESS_BYTE_LEN = 20;
uint8 internal constant ETH_ADDRESS_HEX_LEN = ETH_ADDRESS_BYTE_LEN * 2;
uint8 internal constant CLAIM_PARAM_HASH_BYTE_LEN = 12;
uint8 internal constant CLAIM_PARAM_HASH_HEX_LEN = CLAIM_PARAM_HASH_BYTE_LEN * 2;
uint8 internal constant BITCOIN_SIG_PREFIX_LEN = 24;
bytes24 internal constant BITCOIN_SIG_PREFIX_STR = "Bitcoin Signed Message:\n";
bytes internal constant STD_CLAIM_PREFIX_STR = "Claim_HEX_to_0x";
bytes internal constant OLD_CLAIM_PREFIX_STR = "Claim_BitcoinHEX_to_0x";
bytes16 internal constant HEX_DIGITS = "0123456789abcdef";
/* Claim flags passed to btcAddressClaim() */
uint8 internal constant CLAIM_FLAG_MSG_PREFIX_OLD = 1 << 0;
uint8 internal constant CLAIM_FLAG_BTC_ADDR_COMPRESSED = 1 << 1;
uint8 internal constant CLAIM_FLAG_BTC_ADDR_P2WPKH_IN_P2SH = 1 << 2;
uint8 internal constant CLAIM_FLAG_BTC_ADDR_BECH32 = 1 << 3;
uint8 internal constant CLAIM_FLAG_ETH_ADDR_LOWERCASE = 1 << 4;
/* Globals expanded for memory (except _latestStakeId) and compact for storage */
struct GlobalsCache {
// 1
uint256 _lockedHeartsTotal;
uint256 _nextStakeSharesTotal;
uint256 _shareRate;
uint256 _stakePenaltyTotal;
// 2
uint256 _dailyDataCount;
uint256 _stakeSharesTotal;
uint40 _latestStakeId;
uint256 _unclaimedSatoshisTotal;
uint256 _claimedSatoshisTotal;
uint256 _claimedBtcAddrCount;
//
uint256 _currentDay;
}
struct GlobalsStore {
// 1
uint72 lockedHeartsTotal;
uint72 nextStakeSharesTotal;
uint40 shareRate;
uint72 stakePenaltyTotal;
// 2
uint16 dailyDataCount;
uint72 stakeSharesTotal;
uint40 latestStakeId;
uint128 claimStats;
}
GlobalsStore public globals;
/* Claimed BTC addresses */
mapping(bytes20 => bool) public btcAddressClaims;
/* Daily data */
struct DailyDataStore {
uint72 dayPayoutTotal;
uint72 dayStakeSharesTotal;
uint56 dayUnclaimedSatoshisTotal;
}
mapping(uint256 => DailyDataStore) public dailyData;
/* Stake expanded for memory (except _stakeId) and compact for storage */
struct StakeCache {
uint40 _stakeId;
uint256 _stakedHearts;
uint256 _stakeShares;
uint256 _lockedDay;
uint256 _stakedDays;
uint256 _unlockedDay;
bool _isAutoStake;
}
struct StakeStore {
uint40 stakeId;
uint72 stakedHearts;
uint72 stakeShares;
uint16 lockedDay;
uint16 stakedDays;
uint16 unlockedDay;
bool isAutoStake;
}
mapping(address => StakeStore[]) public stakeLists;
/* Temporary state for calculating daily rounds */
struct DailyRoundState {
uint256 _allocSupplyCached;
uint256 _mintOriginBatch;
uint256 _payoutTotal;
}
struct XfLobbyEntryStore {
uint96 rawAmount;
address referrerAddr;
}
struct XfLobbyQueueStore {
uint40 headIndex;
uint40 tailIndex;
mapping(uint256 => XfLobbyEntryStore) entries;
}
mapping(uint256 => uint256) public xfLobby;
mapping(uint256 => mapping(address => XfLobbyQueueStore)) public xfLobbyMembers;
/**
* @dev PUBLIC FACING: Optionally update daily data for a smaller
* range to reduce gas cost for a subsequent operation
* @param beforeDay Only update days before this day number (optional; 0 for current day)
*/
function dailyDataUpdate(uint256 beforeDay)
external
{
GlobalsCache memory g;
GlobalsCache memory gSnapshot;
_globalsLoad(g, gSnapshot);
/* Skip pre-claim period */
require(g._currentDay > CLAIM_PHASE_START_DAY, "HEX: Too early");
if (beforeDay != 0) {
require(beforeDay <= g._currentDay, "HEX: beforeDay cannot be in the future");
_dailyDataUpdate(g, beforeDay, false);
} else {
/* Default to updating before current day */
_dailyDataUpdate(g, g._currentDay, false);
}
_globalsSync(g, gSnapshot);
}
/**
* @dev PUBLIC FACING: External helper to return multiple values of daily data with
* a single call. Ugly implementation due to limitations of the standard ABI encoder.
* @param beginDay First day of data range
* @param endDay Last day (non-inclusive) of data range
* @return Fixed array of packed values
*/
function dailyDataRange(uint256 beginDay, uint256 endDay)
external
view
returns (uint256[] memory list)
{
require(beginDay < endDay && endDay <= globals.dailyDataCount, "HEX: range invalid");
list = new uint256[](endDay - beginDay);
uint256 src ; //inject UNINIT LOCAL/STATE VAR
uint256 dst ; //inject UNINIT LOCAL/STATE VAR
uint256 v;
do {
v = uint256(dailyData[src].dayUnclaimedSatoshisTotal) << (HEART_UINT_SIZE * 2);
v |= uint256(dailyData[src].dayStakeSharesTotal) << HEART_UINT_SIZE;
v |= uint256(dailyData[src].dayPayoutTotal);
list[dst++] = v;
} while (++src < endDay);
return list;
}
/**
* @dev PUBLIC FACING: External helper to return most global info with a single call.
* Ugly implementation due to limitations of the standard ABI encoder.
* @return Fixed array of values
*/
function globalInfo()
external
view
returns (uint256[13] memory)
{
uint256 _claimedBtcAddrCount;
uint256 _claimedSatoshisTotal;
uint256 _unclaimedSatoshisTotal;
(_claimedBtcAddrCount, _claimedSatoshisTotal, _unclaimedSatoshisTotal) = _claimStatsDecode(
globals.claimStats
);
return [
// 1
globals.lockedHeartsTotal,
globals.nextStakeSharesTotal,
globals.shareRate,
globals.stakePenaltyTotal,
// 2
globals.dailyDataCount,
globals.stakeSharesTotal,
globals.latestStakeId,
_unclaimedSatoshisTotal,
_claimedSatoshisTotal,
_claimedBtcAddrCount,
//
block.timestamp,
totalSupply(),
xfLobby[_currentDay()]
];
}
/**
* @dev PUBLIC FACING: ERC20 totalSupply() is the circulating supply and does not include any
* staked Hearts. allocatedSupply() includes both.
* @return Allocated Supply in Hearts
*/
function allocatedSupply()
external
view
returns (uint256)
{
return totalSupply() + globals.lockedHeartsTotal;
}
/**
* @dev PUBLIC FACING: External helper for the current day number since launch time
* @return Current day number (zero-based)
*/
function currentDay()
external
view
returns (uint256)
{
return _currentDay();
}
function _currentDay()
internal
view
returns (uint256)
{
return (block.timestamp - LAUNCH_TIME) / 1 days;
}
function _dailyDataUpdateAuto(GlobalsCache memory g)
internal
{
_dailyDataUpdate(g, g._currentDay, true);
}
function _globalsLoad(GlobalsCache memory g, GlobalsCache memory gSnapshot)
internal
view
{
// 1
g._lockedHeartsTotal = globals.lockedHeartsTotal;
g._nextStakeSharesTotal = globals.nextStakeSharesTotal;
g._shareRate = globals.shareRate;
g._stakePenaltyTotal = globals.stakePenaltyTotal;
// 2
g._dailyDataCount = globals.dailyDataCount;
g._stakeSharesTotal = globals.stakeSharesTotal;
g._latestStakeId = globals.latestStakeId;
(g._claimedBtcAddrCount, g._claimedSatoshisTotal, g._unclaimedSatoshisTotal) = _claimStatsDecode(
globals.claimStats
);
//
g._currentDay = _currentDay();
_globalsCacheSnapshot(g, gSnapshot);
}
function _globalsCacheSnapshot(GlobalsCache memory g, GlobalsCache memory gSnapshot)
internal
pure
{
// 1
gSnapshot._lockedHeartsTotal = g._lockedHeartsTotal;
gSnapshot._nextStakeSharesTotal = g._nextStakeSharesTotal;
gSnapshot._shareRate = g._shareRate;
gSnapshot._stakePenaltyTotal = g._stakePenaltyTotal;
// 2
gSnapshot._dailyDataCount = g._dailyDataCount;
gSnapshot._stakeSharesTotal = g._stakeSharesTotal;
gSnapshot._latestStakeId = g._latestStakeId;
gSnapshot._unclaimedSatoshisTotal = g._unclaimedSatoshisTotal;
gSnapshot._claimedSatoshisTotal = g._claimedSatoshisTotal;
gSnapshot._claimedBtcAddrCount = g._claimedBtcAddrCount;
}
function _globalsSync(GlobalsCache memory g, GlobalsCache memory gSnapshot)
internal
{
if (g._lockedHeartsTotal != gSnapshot._lockedHeartsTotal
|| g._nextStakeSharesTotal != gSnapshot._nextStakeSharesTotal
|| g._shareRate != gSnapshot._shareRate
|| g._stakePenaltyTotal != gSnapshot._stakePenaltyTotal) {
// 1
globals.lockedHeartsTotal = uint72(g._lockedHeartsTotal);
globals.nextStakeSharesTotal = uint72(g._nextStakeSharesTotal);
globals.shareRate = uint40(g._shareRate);
globals.stakePenaltyTotal = uint72(g._stakePenaltyTotal);
}
if (g._dailyDataCount != gSnapshot._dailyDataCount
|| g._stakeSharesTotal != gSnapshot._stakeSharesTotal
|| g._latestStakeId != gSnapshot._latestStakeId
|| g._unclaimedSatoshisTotal != gSnapshot._unclaimedSatoshisTotal
|| g._claimedSatoshisTotal != gSnapshot._claimedSatoshisTotal
|| g._claimedBtcAddrCount != gSnapshot._claimedBtcAddrCount) {
// 2
globals.dailyDataCount = uint16(g._dailyDataCount);
globals.stakeSharesTotal = uint72(g._stakeSharesTotal);
globals.latestStakeId = g._latestStakeId;
globals.claimStats = _claimStatsEncode(
g._claimedBtcAddrCount,
g._claimedSatoshisTotal,
g._unclaimedSatoshisTotal
);
}
}
function _stakeLoad(StakeStore storage stRef, uint40 stakeIdParam, StakeCache memory st)
internal
view
{
/* Ensure caller's stakeIndex is still current */
require(stakeIdParam == stRef.stakeId, "HEX: stakeIdParam not in stake");
st._stakeId = stRef.stakeId;
st._stakedHearts = stRef.stakedHearts;
st._stakeShares = stRef.stakeShares;
st._lockedDay = stRef.lockedDay;
st._stakedDays = stRef.stakedDays;
st._unlockedDay = stRef.unlockedDay;
st._isAutoStake = stRef.isAutoStake;
}
function _stakeUpdate(StakeStore storage stRef, StakeCache memory st)
internal
{
stRef.stakeId = st._stakeId;
stRef.stakedHearts = uint72(st._stakedHearts);
stRef.stakeShares = uint72(st._stakeShares);
stRef.lockedDay = uint16(st._lockedDay);
stRef.stakedDays = uint16(st._stakedDays);
stRef.unlockedDay = uint16(st._unlockedDay);
stRef.isAutoStake = st._isAutoStake;
}
function _stakeAdd(
StakeStore[] storage stakeListRef,
uint40 newStakeId,
uint256 newStakedHearts,
uint256 newStakeShares,
uint256 newLockedDay,
uint256 newStakedDays,
bool newAutoStake
)
internal
{
stakeListRef.push(
StakeStore(
newStakeId,
uint72(newStakedHearts),
uint72(newStakeShares),
uint16(newLockedDay),
uint16(newStakedDays),
uint16(0), // unlockedDay
newAutoStake
)
);
}
/**
* @dev Efficiently delete from an unordered array by moving the last element
* to the "hole" and reducing the array length. Can change the order of the list
* and invalidate previously held indexes.
* @notice stakeListRef length and stakeIndex are already ensured valid in stakeEnd()
* @param stakeListRef Reference to stakeLists[stakerAddr] array in storage
* @param stakeIndex Index of the element to delete
*/
function _stakeRemove(StakeStore[] storage stakeListRef, uint256 stakeIndex)
internal
{
uint256 lastIndex ; //inject UNINIT LOCAL/STATE VAR
/* Skip the copy if element to be removed is already the last element */
if (stakeIndex != lastIndex) {
/* Copy last element to the requested element's "hole" */
stakeListRef[stakeIndex] = stakeListRef[lastIndex];
}
/*
Reduce the array length now that the array is contiguous.
Surprisingly, 'pop()' uses less gas than 'stakeListRef.length = lastIndex'
*/
stakeListRef.pop();
}
function _claimStatsEncode(
uint256 _claimedBtcAddrCount,
uint256 _claimedSatoshisTotal,
uint256 _unclaimedSatoshisTotal
)
internal
pure
returns (uint128)
{
uint256 v ; //inject UNINIT LOCAL/STATE VAR
v |= _claimedSatoshisTotal << SATOSHI_UINT_SIZE;
v |= _unclaimedSatoshisTotal;
return uint128(v);
}
function _claimStatsDecode(uint128 v)
internal
pure
returns (uint256 _claimedBtcAddrCount, uint256 _claimedSatoshisTotal, uint256 _unclaimedSatoshisTotal)
{
_claimedBtcAddrCount = v >> (SATOSHI_UINT_SIZE * 2);
_claimedSatoshisTotal = (v >> SATOSHI_UINT_SIZE) & SATOSHI_UINT_MASK;
_unclaimedSatoshisTotal = v & SATOSHI_UINT_MASK;
return (_claimedBtcAddrCount, _claimedSatoshisTotal, _unclaimedSatoshisTotal);
}
/**
* @dev Estimate the stake payout for an incomplete day
* @param g Cache of stored globals
* @param stakeSharesParam Param from stake to calculate bonuses for
* @param day Day to calculate bonuses for
* @return Payout in Hearts
*/
function _estimatePayoutRewardsDay(GlobalsCache memory g, uint256 stakeSharesParam, uint256 day)
internal
view
returns (uint256 payout)
{
/* Prevent updating state for this estimation */
GlobalsCache memory gTmp;
_globalsCacheSnapshot(g, gTmp);
DailyRoundState memory rs;
rs._allocSupplyCached = totalSupply() + g._lockedHeartsTotal;
_dailyRoundCalc(gTmp, rs, day);
/* Stake is no longer locked so it must be added to total as if it were */
gTmp._stakeSharesTotal += stakeSharesParam;
payout = rs._payoutTotal * stakeSharesParam / gTmp._stakeSharesTotal;
if (day == BIG_PAY_DAY) {
uint256 bigPaySlice ; //inject UNINIT LOCAL/STATE VAR
payout += bigPaySlice + _calcAdoptionBonus(gTmp, bigPaySlice);
}
return payout;
}
function _calcAdoptionBonus(GlobalsCache memory g, uint256 payout)
internal
pure
returns (uint256)
{
/*
VIRAL REWARDS: Add adoption percentage bonus to payout
viral = payout * (claimedBtcAddrCount / CLAIMABLE_BTC_ADDR_COUNT)
*/
uint256 viral ; //inject UNINIT LOCAL/STATE VAR
/*
CRIT MASS REWARDS: Add adoption percentage bonus to payout
crit = payout * (claimedSatoshisTotal / CLAIMABLE_SATOSHIS_TOTAL)
*/
uint256 crit ; //inject UNINIT LOCAL/STATE VAR
return viral + crit;
}
function _dailyRoundCalc(GlobalsCache memory g, DailyRoundState memory rs, uint256 day)
private
pure
{
/*
Calculate payout round
Inflation of 3.69% inflation per 364 days (approx 1 year)
dailyInterestRate = exp(log(1 + 3.69%) / 364) - 1
= exp(log(1 + 0.0369) / 364) - 1
= exp(log(1.0369) / 364) - 1
= 0.000099553011616349 (approx)
payout = allocSupply * dailyInterestRate
= allocSupply / (1 / dailyInterestRate)
= allocSupply / (1 / 0.000099553011616349)
= allocSupply / 10044.899534066692 (approx)
= allocSupply * 10000 / 100448995 (* 10000/10000 for int precision)
*/
rs._payoutTotal = rs._allocSupplyCached * 10000 / 100448995;
if (day < CLAIM_PHASE_END_DAY) {
uint256 bigPaySlice ; //inject UNINIT LOCAL/STATE VAR
uint256 originBonus ; //inject UNINIT LOCAL/STATE VAR
rs._mintOriginBatch += originBonus;
rs._allocSupplyCached += originBonus;
rs._payoutTotal += _calcAdoptionBonus(g, rs._payoutTotal);
}
if (g._stakePenaltyTotal != 0) {
rs._payoutTotal += g._stakePenaltyTotal;
g._stakePenaltyTotal = 0;
}
}
function _dailyRoundCalcAndStore(GlobalsCache memory g, DailyRoundState memory rs, uint256 day)
private
{
_dailyRoundCalc(g, rs, day);
dailyData[day].dayPayoutTotal = uint72(rs._payoutTotal);
dailyData[day].dayStakeSharesTotal = uint72(g._stakeSharesTotal);
dailyData[day].dayUnclaimedSatoshisTotal = uint56(g._unclaimedSatoshisTotal);
}
function _dailyDataUpdate(GlobalsCache memory g, uint256 beforeDay, bool isAutoUpdate)
private
{
if (g._dailyDataCount >= beforeDay) {
/* Already up-to-date */
return;
}
DailyRoundState memory rs;
rs._allocSupplyCached = totalSupply() + g._lockedHeartsTotal;
uint256 day ; //inject UNINIT LOCAL/STATE VAR
_dailyRoundCalcAndStore(g, rs, day);
/* Stakes started during this day are added to the total the next day */
if (g._nextStakeSharesTotal != 0) {
g._stakeSharesTotal += g._nextStakeSharesTotal;
g._nextStakeSharesTotal = 0;
}
while (++day < beforeDay) {
_dailyRoundCalcAndStore(g, rs, day);
}
_emitDailyDataUpdate(g._dailyDataCount, day, isAutoUpdate);
g._dailyDataCount = day;
if (rs._mintOriginBatch != 0) {
_mint(ORIGIN_ADDR, rs._mintOriginBatch);
}
}
function _emitDailyDataUpdate(uint256 beginDay, uint256 endDay, bool isAutoUpdate)
private
{
emit DailyDataUpdate( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint16(beginDay)) << 40)
| (uint256(uint16(endDay)) << 56)
| (isAutoUpdate ? (1 << 72) : 0),
msg.sender
);
}
}
contract StakeableToken is GlobalsAndUtility {
/**
* @dev PUBLIC FACING: Open a stake.
* @param newStakedHearts Number of Hearts to stake
* @param newStakedDays Number of days to stake
*/
function stakeStart(uint256 newStakedHearts, uint256 newStakedDays)
external
{
GlobalsCache memory g;
GlobalsCache memory gSnapshot;
_globalsLoad(g, gSnapshot);
/* Enforce the minimum stake time */
require(newStakedDays >= MIN_STAKE_DAYS, "HEX: newStakedDays lower than minimum");
/* Check if log data needs to be updated */
_dailyDataUpdateAuto(g);
_stakeStart(g, newStakedHearts, newStakedDays, false);
/* Remove staked Hearts from balance of staker */
_burn(msg.sender, newStakedHearts);
_globalsSync(g, gSnapshot);
}
/**
* @dev PUBLIC FACING: Unlocks a completed stake, distributing the proceeds of any penalty
* immediately. The staker must still call stakeEnd() to retrieve their stake return (if any).
* @param stakerAddr Address of staker
* @param stakeIndex Index of stake within stake list
* @param stakeIdParam The stake's id
*/
function stakeGoodAccounting(address stakerAddr, uint256 stakeIndex, uint40 stakeIdParam)
external
{
GlobalsCache memory g;
GlobalsCache memory gSnapshot;
_globalsLoad(g, gSnapshot);
/* require() is more informative than the default assert() */
require(stakeLists[stakerAddr].length != 0, "HEX: Empty stake list");
require(stakeIndex < stakeLists[stakerAddr].length, "HEX: stakeIndex invalid");
StakeStore storage stRef = stakeLists[stakerAddr][stakeIndex];
/* Get stake copy */
StakeCache memory st;
_stakeLoad(stRef, stakeIdParam, st);
/* Stake must have served full term */
require(g._currentDay >= st._lockedDay + st._stakedDays, "HEX: Stake not fully served");
/* Stake must still be locked */
require(st._unlockedDay == 0, "HEX: Stake already unlocked");
/* Check if log data needs to be updated */
_dailyDataUpdateAuto(g);
/* Unlock the completed stake */
_stakeUnlock(g, st);
/* stakeReturn value is unused here */
(, uint256 payout, uint256 penalty, uint256 cappedPenalty) = _stakePerformance(
g,
st,
st._stakedDays
);
_emitStakeGoodAccounting(
stakerAddr,
stakeIdParam,
st._stakedHearts,
st._stakeShares,
payout,
penalty
);
if (cappedPenalty != 0) {
_splitPenaltyProceeds(g, cappedPenalty);
}
/* st._unlockedDay has changed */
_stakeUpdate(stRef, st);
_globalsSync(g, gSnapshot);
}
/**
* @dev PUBLIC FACING: Closes a stake. The order of the stake list can change so
* a stake id is used to reject stale indexes.
* @param stakeIndex Index of stake within stake list
* @param stakeIdParam The stake's id
*/
function stakeEnd(uint256 stakeIndex, uint40 stakeIdParam)
external
{
GlobalsCache memory g;
GlobalsCache memory gSnapshot;
_globalsLoad(g, gSnapshot);
StakeStore[] storage stakeListRef = stakeLists[msg.sender];
/* require() is more informative than the default assert() */
require(stakeListRef.length != 0, "HEX: Empty stake list");
require(stakeIndex < stakeListRef.length, "HEX: stakeIndex invalid");
/* Get stake copy */
StakeCache memory st;
_stakeLoad(stakeListRef[stakeIndex], stakeIdParam, st);
/* Check if log data needs to be updated */
_dailyDataUpdateAuto(g);
uint256 servedDays ; //inject UNINIT LOCAL/STATE VAR
bool prevUnlocked ; //inject UNINIT LOCAL/STATE VAR
uint256 stakeReturn;
uint256 payout ; //inject UNINIT LOCAL/STATE VAR
uint256 penalty ; //inject UNINIT LOCAL/STATE VAR
uint256 cappedPenalty ; //inject UNINIT LOCAL/STATE VAR
if (g._currentDay >= st._lockedDay) {
if (prevUnlocked) {
/* Previously unlocked in stakeGoodAccounting(), so must have served full term */
servedDays = st._stakedDays;
} else {
_stakeUnlock(g, st);
servedDays = g._currentDay - st._lockedDay;
if (servedDays > st._stakedDays) {
servedDays = st._stakedDays;
} else {
/* Deny early-unstake before an auto-stake minimum has been served */
if (servedDays < MIN_AUTO_STAKE_DAYS) {
require(!st._isAutoStake, "HEX: Auto-stake still locked");
}
}
}
(stakeReturn, payout, penalty, cappedPenalty) = _stakePerformance(g, st, servedDays);
} else {
/* Deny early-unstake before an auto-stake minimum has been served */
require(!st._isAutoStake, "HEX: Auto-stake still locked");
/* Stake hasn't been added to the total yet, so no penalties or rewards apply */
g._nextStakeSharesTotal -= st._stakeShares;
stakeReturn = st._stakedHearts;
}
_emitStakeEnd(
stakeIdParam,
st._stakedHearts,
st._stakeShares,
payout,
penalty,
servedDays,
prevUnlocked
);
if (cappedPenalty != 0 && !prevUnlocked) {
/* Split penalty proceeds only if not previously unlocked by stakeGoodAccounting() */
_splitPenaltyProceeds(g, cappedPenalty);
}
/* Pay the stake return, if any, to the staker */
if (stakeReturn != 0) {
_mint(msg.sender, stakeReturn);
/* Update the share rate if necessary */
_shareRateUpdate(g, st, stakeReturn);
}
g._lockedHeartsTotal -= st._stakedHearts;
_stakeRemove(stakeListRef, stakeIndex);
_globalsSync(g, gSnapshot);
}
/**
* @dev PUBLIC FACING: Return the current stake count for a staker address
* @param stakerAddr Address of staker
*/
function stakeCount(address stakerAddr)
external
view
returns (uint256)
{
return stakeLists[stakerAddr].length;
}
/**
* @dev Open a stake.
* @param g Cache of stored globals
* @param newStakedHearts Number of Hearts to stake
* @param newStakedDays Number of days to stake
* @param newAutoStake Stake is automatic directly from a new claim
*/
function _stakeStart(
GlobalsCache memory g,
uint256 newStakedHearts,
uint256 newStakedDays,
bool newAutoStake
)
internal
{
/* Enforce the maximum stake time */
require(newStakedDays <= MAX_STAKE_DAYS, "HEX: newStakedDays higher than maximum");
uint256 bonusHearts ; //inject UNINIT LOCAL/STATE VAR
uint256 newStakeShares ; //inject UNINIT LOCAL/STATE VAR
/* Ensure newStakedHearts is enough for at least one stake share */
require(newStakeShares != 0, "HEX: newStakedHearts must be at least minimum shareRate");
/*
The stakeStart timestamp will always be part-way through the current
day, so it needs to be rounded-up to the next day to ensure all
stakes align with the same fixed calendar days. The current day is
already rounded-down, so rounded-up is current day + 1.
*/
uint256 newLockedDay ; //inject UNINIT LOCAL/STATE VAR
/* Create Stake */
uint40 newStakeId ; //inject UNINIT LOCAL/STATE VAR
_stakeAdd(
stakeLists[msg.sender],
newStakeId,
newStakedHearts,
newStakeShares,
newLockedDay,
newStakedDays,
newAutoStake
);
_emitStakeStart(newStakeId, newStakedHearts, newStakeShares, newStakedDays, newAutoStake);
/* Stake is added to total in the next round, not the current round */
g._nextStakeSharesTotal += newStakeShares;
/* Track total staked Hearts for inflation calculations */
g._lockedHeartsTotal += newStakedHearts;
}
/**
* @dev Calculates total stake payout including rewards for a multi-day range
* @param g Cache of stored globals
* @param stakeSharesParam Param from stake to calculate bonuses for
* @param beginDay First day to calculate bonuses for
* @param endDay Last day (non-inclusive) of range to calculate bonuses for
* @return Payout in Hearts
*/
function _calcPayoutRewards(
GlobalsCache memory g,
uint256 stakeSharesParam,
uint256 beginDay,
uint256 endDay
)
private
view
returns (uint256 payout)
{
for (uint256 day ; day < endDay; day++) { //inject UNINIT LOCAL/STATE VAR
payout += dailyData[day].dayPayoutTotal * stakeSharesParam
/ dailyData[day].dayStakeSharesTotal;
}
/* Less expensive to re-read storage than to have the condition inside the loop */
if (beginDay <= BIG_PAY_DAY && endDay > BIG_PAY_DAY) {
uint256 bigPaySlice ; //inject UNINIT LOCAL/STATE VAR
payout += bigPaySlice + _calcAdoptionBonus(g, bigPaySlice);
}
return payout;
}
/**
* @dev Calculate bonus Hearts for a new stake, if any
* @param newStakedHearts Number of Hearts to stake
* @param newStakedDays Number of days to stake
*/
function _stakeStartBonusHearts(uint256 newStakedHearts, uint256 newStakedDays)
private
pure
returns (uint256 bonusHearts)
{
/*
LONGER PAYS BETTER:
If longer than 1 day stake is committed to, each extra day
gives bonus shares of approximately 0.0548%, which is approximately 20%
extra per year of increased stake length committed to, but capped to a
maximum of 200% extra.
extraDays = stakedDays - 1
longerBonus% = (extraDays / 364) * 20%
= (extraDays / 364) / 5
= extraDays / 1820
= extraDays / LPB
extraDays = longerBonus% * 1820
extraDaysMax = longerBonusMax% * 1820
= 200% * 1820
= 3640
= LPB_MAX_DAYS
BIGGER PAYS BETTER:
Bonus percentage scaled 0% to 10% for the first 150M HEX of stake.
biggerBonus% = (cappedHearts / BPB_MAX_HEARTS) * 10%
= (cappedHearts / BPB_MAX_HEARTS) / 10
= cappedHearts / (BPB_MAX_HEARTS * 10)
= cappedHearts / BPB
COMBINED:
combinedBonus% = longerBonus% + biggerBonus%
cappedExtraDays cappedHearts
= --------------- + ------------
LPB BPB
cappedExtraDays * BPB cappedHearts * LPB
= --------------------- + ------------------
LPB * BPB LPB * BPB
cappedExtraDays * BPB + cappedHearts * LPB
= --------------------------------------------
LPB * BPB
bonusHearts = hearts * combinedBonus%
= hearts * (cappedExtraDays * BPB + cappedHearts * LPB) / (LPB * BPB)
*/
uint256 cappedExtraDays ; //inject UNINIT LOCAL/STATE VAR
/* Must be more than 1 day for Longer-Pays-Better */
if (newStakedDays > 1) {
cappedExtraDays = newStakedDays <= LPB_MAX_DAYS ? newStakedDays - 1 : LPB_MAX_DAYS;
}
uint256 cappedStakedHearts ; //inject UNINIT LOCAL/STATE VAR
bonusHearts = cappedExtraDays * BPB + cappedStakedHearts * LPB;
bonusHearts = newStakedHearts * bonusHearts / (LPB * BPB);
return bonusHearts;
}
function _stakeUnlock(GlobalsCache memory g, StakeCache memory st)
private
pure
{
g._stakeSharesTotal -= st._stakeShares;
st._unlockedDay = g._currentDay;
}
function _stakePerformance(GlobalsCache memory g, StakeCache memory st, uint256 servedDays)
private
view
returns (uint256 stakeReturn, uint256 payout, uint256 penalty, uint256 cappedPenalty)
{
if (servedDays < st._stakedDays) {
(payout, penalty) = _calcPayoutAndEarlyPenalty(
g,
st._lockedDay,
st._stakedDays,
servedDays,
st._stakeShares
);
stakeReturn = st._stakedHearts + payout;
} else {
// servedDays must == stakedDays here
payout = _calcPayoutRewards(
g,
st._stakeShares,
st._lockedDay,
st._lockedDay + servedDays
);
stakeReturn = st._stakedHearts + payout;
penalty = _calcLatePenalty(st._lockedDay, st._stakedDays, st._unlockedDay, stakeReturn);
}
if (penalty != 0) {
if (penalty > stakeReturn) {
/* Cannot have a negative stake return */
cappedPenalty = stakeReturn;
stakeReturn = 0;
} else {
/* Remove penalty from the stake return */
cappedPenalty = penalty;
stakeReturn -= cappedPenalty;
}
}
return (stakeReturn, payout, penalty, cappedPenalty);
}
function _calcPayoutAndEarlyPenalty(
GlobalsCache memory g,
uint256 lockedDayParam,
uint256 stakedDaysParam,
uint256 servedDays,
uint256 stakeSharesParam
)
private
view
returns (uint256 payout, uint256 penalty)
{
uint256 servedEndDay ; //inject UNINIT LOCAL/STATE VAR
/* 50% of stakedDays (rounded up) with a minimum applied */
uint256 penaltyDays ; //inject UNINIT LOCAL/STATE VAR
if (penaltyDays < EARLY_PENALTY_MIN_DAYS) {
penaltyDays = EARLY_PENALTY_MIN_DAYS;
}
if (servedDays == 0) {
/* Fill penalty days with the estimated average payout */
uint256 expected ; //inject UNINIT LOCAL/STATE VAR
penalty = expected * penaltyDays;
return (payout, penalty); // Actual payout was 0
}
if (penaltyDays < servedDays) {
/*
Simplified explanation of intervals where end-day is non-inclusive:
penalty: [lockedDay ... penaltyEndDay)
delta: [penaltyEndDay ... servedEndDay)
payout: [lockedDay ....................... servedEndDay)
*/
uint256 penaltyEndDay ; //inject UNINIT LOCAL/STATE VAR
penalty = _calcPayoutRewards(g, stakeSharesParam, lockedDayParam, penaltyEndDay);
uint256 delta ; //inject UNINIT LOCAL/STATE VAR
payout = penalty + delta;
return (payout, penalty);
}
/* penaltyDays >= servedDays */
payout = _calcPayoutRewards(g, stakeSharesParam, lockedDayParam, servedEndDay);
if (penaltyDays == servedDays) {
penalty = payout;
} else {
/*
(penaltyDays > servedDays) means not enough days served, so fill the
penalty days with the average payout from only the days that were served.
*/
penalty = payout * penaltyDays / servedDays;
}
return (payout, penalty);
}
function _calcLatePenalty(
uint256 lockedDayParam,
uint256 stakedDaysParam,
uint256 unlockedDayParam,
uint256 rawStakeReturn
)
private
pure
returns (uint256)
{
/* Allow grace time before penalties accrue */
uint256 maxUnlockedDay ; //inject UNINIT LOCAL/STATE VAR
if (unlockedDayParam <= maxUnlockedDay) {
return 0;
}
/* Calculate penalty as a percentage of stake return based on time */
return rawStakeReturn * (unlockedDayParam - maxUnlockedDay) / LATE_PENALTY_SCALE_DAYS;
}
function _splitPenaltyProceeds(GlobalsCache memory g, uint256 penalty)
private
{
/* Split a penalty 50:50 between Origin and stakePenaltyTotal */
uint256 splitPenalty ; //inject UNINIT LOCAL/STATE VAR
if (splitPenalty != 0) {
_mint(ORIGIN_ADDR, splitPenalty);
}
/* Use the other half of the penalty to account for an odd-numbered penalty */
splitPenalty = penalty - splitPenalty;
g._stakePenaltyTotal += splitPenalty;
}
function _shareRateUpdate(GlobalsCache memory g, StakeCache memory st, uint256 stakeReturn)
private
{
if (stakeReturn > st._stakedHearts) {
/*
Calculate the new shareRate that would yield the same number of shares if
the user re-staked this stakeReturn, factoring in any bonuses they would
receive in stakeStart().
*/
uint256 bonusHearts ; //inject UNINIT LOCAL/STATE VAR
uint256 newShareRate ; //inject UNINIT LOCAL/STATE VAR
if (newShareRate > SHARE_RATE_MAX) {
/*
Realistically this can't happen, but there are contrived theoretical
scenarios that can lead to extreme values of newShareRate, so it is
capped to prevent them anyway.
*/
newShareRate = SHARE_RATE_MAX;
}
if (newShareRate > g._shareRate) {
g._shareRate = newShareRate;
_emitShareRateChange(newShareRate, st._stakeId);
}
}
}
function _emitStakeStart(
uint40 stakeId,
uint256 stakedHearts,
uint256 stakeShares,
uint256 stakedDays,
bool isAutoStake
)
private
{
emit StakeStart( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint72(stakedHearts)) << 40)
| (uint256(uint72(stakeShares)) << 112)
| (uint256(uint16(stakedDays)) << 184)
| (isAutoStake ? (1 << 200) : 0),
msg.sender,
stakeId
);
}
function _emitStakeGoodAccounting(
address stakerAddr,
uint40 stakeId,
uint256 stakedHearts,
uint256 stakeShares,
uint256 payout,
uint256 penalty
)
private
{
emit StakeGoodAccounting( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint72(stakedHearts)) << 40)
| (uint256(uint72(stakeShares)) << 112)
| (uint256(uint72(payout)) << 184),
uint256(uint72(penalty)),
stakerAddr,
stakeId,
msg.sender
);
}
function _emitStakeEnd(
uint40 stakeId,
uint256 stakedHearts,
uint256 stakeShares,
uint256 payout,
uint256 penalty,
uint256 servedDays,
bool prevUnlocked
)
private
{
emit StakeEnd( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint72(stakedHearts)) << 40)
| (uint256(uint72(stakeShares)) << 112)
| (uint256(uint72(payout)) << 184),
uint256(uint72(penalty))
| (uint256(uint16(servedDays)) << 72)
| (prevUnlocked ? (1 << 88) : 0),
msg.sender,
stakeId
);
}
function _emitShareRateChange(uint256 shareRate, uint40 stakeId)
private
{
emit ShareRateChange( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint40(shareRate)) << 40),
stakeId
);
}
}
/**
* @dev These functions deal with verification of Merkle trees (hash trees),
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
bytes32 computedHash ; //inject UNINIT LOCAL/STATE VAR
for (uint256 i ; i < proof.length; i++) { //inject UNINIT LOCAL/STATE VAR
bytes32 proofElement ; //inject UNINIT LOCAL/STATE VAR
if (computedHash < proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
// Hash(current element of the proof + current computed hash)
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
// Check if the computed hash (root) is equal to the provided root
return computedHash == root;
}
}
contract UTXOClaimValidation is StakeableToken {
/**
* @dev PUBLIC FACING: Verify a BTC address and balance are unclaimed and part of the Merkle tree
* @param btcAddr Bitcoin address (binary; no base58-check encoding)
* @param rawSatoshis Raw BTC address balance in Satoshis
* @param proof Merkle tree proof
* @return True if can be claimed
*/
function btcAddressIsClaimable(bytes20 btcAddr, uint256 rawSatoshis, bytes32[] calldata proof)
external
view
returns (bool)
{
uint256 day ; //inject UNINIT LOCAL/STATE VAR
require(day >= CLAIM_PHASE_START_DAY, "HEX: Claim phase has not yet started");
require(day < CLAIM_PHASE_END_DAY, "HEX: Claim phase has ended");
/* Don't need to check Merkle proof if UTXO BTC address has already been claimed */
if (btcAddressClaims[btcAddr]) {
return false;
}
/* Verify the Merkle tree proof */
return _btcAddressIsValid(btcAddr, rawSatoshis, proof);
}
/**
* @dev PUBLIC FACING: Verify a BTC address and balance are part of the Merkle tree
* @param btcAddr Bitcoin address (binary; no base58-check encoding)
* @param rawSatoshis Raw BTC address balance in Satoshis
* @param proof Merkle tree proof
* @return True if valid
*/
function btcAddressIsValid(bytes20 btcAddr, uint256 rawSatoshis, bytes32[] calldata proof)
external
pure
returns (bool)
{
return _btcAddressIsValid(btcAddr, rawSatoshis, proof);
}
/**
* @dev PUBLIC FACING: Verify a Merkle proof using the UTXO Merkle tree
* @param merkleLeaf Leaf asserted to be present in the Merkle tree
* @param proof Generated Merkle tree proof
* @return True if valid
*/
function merkleProofIsValid(bytes32 merkleLeaf, bytes32[] calldata proof)
external
pure
returns (bool)
{
return _merkleProofIsValid(merkleLeaf, proof);
}
/**
* @dev PUBLIC FACING: Verify that a Bitcoin signature matches the claim message containing
* the Ethereum address and claim param hash
* @param claimToAddr Eth address within the signed claim message
* @param claimParamHash Param hash within the signed claim message
* @param pubKeyX First half of uncompressed ECDSA public key
* @param pubKeyY Second half of uncompressed ECDSA public key
* @param claimFlags Claim flags specifying address and message formats
* @param v v parameter of ECDSA signature
* @param r r parameter of ECDSA signature
* @param s s parameter of ECDSA signature
* @return True if matching
*/
function claimMessageMatchesSignature(
address claimToAddr,
bytes32 claimParamHash,
bytes32 pubKeyX,
bytes32 pubKeyY,
uint8 claimFlags,
uint8 v,
bytes32 r,
bytes32 s
)
public
pure
returns (bool)
{
require(v >= 27 && v <= 30, "HEX: v invalid");
/*
ecrecover() returns an Eth address rather than a public key, so
we must do the same to compare.
*/
address pubKeyEthAddr ; //inject UNINIT LOCAL/STATE VAR
/* Create and hash the claim message text */
bytes32 messageHash ; //inject UNINIT LOCAL/STATE VAR
/* Verify the public key */
return ecrecover(messageHash, v, r, s) == pubKeyEthAddr;
}
/**
* @dev PUBLIC FACING: Derive an Ethereum address from an ECDSA public key
* @param pubKeyX First half of uncompressed ECDSA public key
* @param pubKeyY Second half of uncompressed ECDSA public key
* @return Derived Eth address
*/
function pubKeyToEthAddress(bytes32 pubKeyX, bytes32 pubKeyY)
public
pure
returns (address)
{
return address(uint160(uint256(keccak256(abi.encodePacked(pubKeyX, pubKeyY)))));
}
/**
* @dev PUBLIC FACING: Derive a Bitcoin address from an ECDSA public key
* @param pubKeyX First half of uncompressed ECDSA public key
* @param pubKeyY Second half of uncompressed ECDSA public key
* @param claimFlags Claim flags specifying address and message formats
* @return Derived Bitcoin address (binary; no base58-check encoding)
*/
function pubKeyToBtcAddress(bytes32 pubKeyX, bytes32 pubKeyY, uint8 claimFlags)
public
pure
returns (bytes20)
{
/*
Helpful references:
- https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses
- https://github.com/cryptocoinjs/ecurve/blob/master/lib/point.js
*/
uint8 startingByte;
bytes memory pubKey;
bool compressed ; //inject UNINIT LOCAL/STATE VAR
bool nested ; //inject UNINIT LOCAL/STATE VAR
bool bech32 ; //inject UNINIT LOCAL/STATE VAR
if (compressed) {
/* Compressed public key format */
require(!(nested && bech32), "HEX: claimFlags invalid");
startingByte = (pubKeyY[31] & 0x01) == 0 ? 0x02 : 0x03;
pubKey = abi.encodePacked(startingByte, pubKeyX);
} else {
/* Uncompressed public key format */
require(!nested && !bech32, "HEX: claimFlags invalid");
startingByte = 0x04;
pubKey = abi.encodePacked(startingByte, pubKeyX, pubKeyY);
}
bytes20 pubKeyHash ; //inject UNINIT LOCAL/STATE VAR
if (nested) {
return _hash160(abi.encodePacked(hex"0014", pubKeyHash));
}
return pubKeyHash;
}
/**
* @dev Verify a BTC address and balance are part of the Merkle tree
* @param btcAddr Bitcoin address (binary; no base58-check encoding)
* @param rawSatoshis Raw BTC address balance in Satoshis
* @param proof Merkle tree proof
* @return True if valid
*/
function _btcAddressIsValid(bytes20 btcAddr, uint256 rawSatoshis, bytes32[] memory proof)
internal
pure
returns (bool)
{
/*
Ensure the proof does not attempt to treat a Merkle leaf as if it were an
internal Merkle tree node. A leaf will always have the zero-fill. An
internal node will never have the zero-fill, as guaranteed by HEX's Merkle
tree construction.
The first element, proof[0], will always be a leaf because it is the pair
of the leaf being validated. The rest of the elements, proof[1..length-1],
must be internal nodes.
The number of leaves (CLAIMABLE_BTC_ADDR_COUNT) is even, as guaranteed by
HEX's Merkle tree construction, which eliminates the only edge-case where
this validation would not apply.
*/
require((uint256(proof[0]) & MERKLE_LEAF_FILL_MASK) == 0, "HEX: proof invalid");
for (uint256 i ; i < proof.length; i++) { //inject UNINIT LOCAL/STATE VAR
require((uint256(proof[i]) & MERKLE_LEAF_FILL_MASK) != 0, "HEX: proof invalid");
}
/*
Calculate the 32 byte Merkle leaf associated with this BTC address and balance
160 bits: BTC address
52 bits: Zero-fill
45 bits: Satoshis (limited by MAX_BTC_ADDR_BALANCE_SATOSHIS)
*/
bytes32 merkleLeaf ; //inject UNINIT LOCAL/STATE VAR
/* Verify the Merkle tree proof */
return _merkleProofIsValid(merkleLeaf, proof);
}
/**
* @dev Verify a Merkle proof using the UTXO Merkle tree
* @param merkleLeaf Leaf asserted to be present in the Merkle tree
* @param proof Generated Merkle tree proof
* @return True if valid
*/
function _merkleProofIsValid(bytes32 merkleLeaf, bytes32[] memory proof)
private
pure
returns (bool)
{
return MerkleProof.verify(proof, MERKLE_TREE_ROOT, merkleLeaf);
}
function _claimMessageCreate(address claimToAddr, bytes32 claimParamHash, uint8 claimFlags)
private
pure
returns (bytes memory)
{
bytes memory prefixStr = (claimFlags & CLAIM_FLAG_MSG_PREFIX_OLD) != 0
? OLD_CLAIM_PREFIX_STR
: STD_CLAIM_PREFIX_STR;
bool includeAddrChecksum ; //inject UNINIT LOCAL/STATE VAR
bytes memory addrStr = _addressStringCreate(claimToAddr, includeAddrChecksum);
if (claimParamHash == 0) {
return abi.encodePacked(
BITCOIN_SIG_PREFIX_LEN,
BITCOIN_SIG_PREFIX_STR,
uint8(prefixStr.length) + ETH_ADDRESS_HEX_LEN,
prefixStr,
addrStr
);
}
bytes memory claimParamHashStr = new bytes(CLAIM_PARAM_HASH_HEX_LEN);
_hexStringFromData(claimParamHashStr, claimParamHash, CLAIM_PARAM_HASH_BYTE_LEN);
return abi.encodePacked(
BITCOIN_SIG_PREFIX_LEN,
BITCOIN_SIG_PREFIX_STR,
uint8(prefixStr.length) + ETH_ADDRESS_HEX_LEN + 1 + CLAIM_PARAM_HASH_HEX_LEN,
prefixStr,
addrStr,
"_",
claimParamHashStr
);
}
function _addressStringCreate(address addr, bool includeAddrChecksum)
private
pure
returns (bytes memory addrStr)
{
addrStr = new bytes(ETH_ADDRESS_HEX_LEN);
_hexStringFromData(addrStr, bytes32(bytes20(addr)), ETH_ADDRESS_BYTE_LEN);
if (includeAddrChecksum) {
bytes32 addrStrHash ; //inject UNINIT LOCAL/STATE VAR
uint256 offset ; //inject UNINIT LOCAL/STATE VAR
for (uint256 i ; i < ETH_ADDRESS_BYTE_LEN; i++) { //inject UNINIT LOCAL/STATE VAR
uint8 b ; //inject UNINIT LOCAL/STATE VAR
_addressStringChecksumChar(addrStr, offset++, b >> 4);
_addressStringChecksumChar(addrStr, offset++, b & 0x0f);
}
}
return addrStr;
}
function _addressStringChecksumChar(bytes memory addrStr, uint256 offset, uint8 hashNybble)
private
pure
{
bytes1 ch ; //inject UNINIT LOCAL/STATE VAR
if (ch >= "a" && hashNybble >= 8) {
addrStr[offset] = ch ^ 0x20;
}
}
function _hexStringFromData(bytes memory hexStr, bytes32 data, uint256 dataLen)
private
pure
{
uint256 offset ; //inject UNINIT LOCAL/STATE VAR
for (uint256 i ; i < dataLen; i++) { //inject UNINIT LOCAL/STATE VAR
uint8 b ; //inject UNINIT LOCAL/STATE VAR
hexStr[offset++] = HEX_DIGITS[b >> 4];
hexStr[offset++] = HEX_DIGITS[b & 0x0f];
}
}
/**
* @dev sha256(sha256(data))
* @param data Data to be hashed
* @return 32-byte hash
*/
function _hash256(bytes memory data)
private
pure
returns (bytes32)
{
return sha256(abi.encodePacked(sha256(data)));
}
/**
* @dev ripemd160(sha256(data))
* @param data Data to be hashed
* @return 20-byte hash
*/
function _hash160(bytes memory data)
private
pure
returns (bytes20)
{
return ripemd160(abi.encodePacked(sha256(data)));
}
}
contract UTXORedeemableToken is UTXOClaimValidation {
/**
* @dev PUBLIC FACING: Claim a BTC address and its Satoshi balance in Hearts
* crediting the appropriate amount to a specified Eth address. Bitcoin ECDSA
* signature must be from that BTC address and must match the claim message
* for the Eth address.
* @param rawSatoshis Raw BTC address balance in Satoshis
* @param proof Merkle tree proof
* @param claimToAddr Destination Eth address to credit Hearts to
* @param pubKeyX First half of uncompressed ECDSA public key for the BTC address
* @param pubKeyY Second half of uncompressed ECDSA public key for the BTC address
* @param claimFlags Claim flags specifying address and message formats
* @param v v parameter of ECDSA signature
* @param r r parameter of ECDSA signature
* @param s s parameter of ECDSA signature
* @param autoStakeDays Number of days to auto-stake, subject to minimum auto-stake days
* @param referrerAddr Eth address of referring user (optional; 0x0 for no referrer)
* @return Total number of Hearts credited, if successful
*/
function btcAddressClaim(
uint256 rawSatoshis,
bytes32[] calldata proof,
address claimToAddr,
bytes32 pubKeyX,
bytes32 pubKeyY,
uint8 claimFlags,
uint8 v,
bytes32 r,
bytes32 s,
uint256 autoStakeDays,
address referrerAddr
)
external
returns (uint256)
{
/* Sanity check */
require(rawSatoshis <= MAX_BTC_ADDR_BALANCE_SATOSHIS, "HEX: CHK: rawSatoshis");
/* Enforce the minimum stake time for the auto-stake from this claim */
require(autoStakeDays >= MIN_AUTO_STAKE_DAYS, "HEX: autoStakeDays lower than minimum");
/* Ensure signature matches the claim message containing the Eth address and claimParamHash */
{
bytes32 claimParamHash ; //inject UNINIT LOCAL/STATE VAR
if (claimToAddr != msg.sender) {
/* Claimer did not send this, so claim params must be signed */
claimParamHash = keccak256(
abi.encodePacked(MERKLE_TREE_ROOT, autoStakeDays, referrerAddr)
);
}
require(
claimMessageMatchesSignature(
claimToAddr,
claimParamHash,
pubKeyX,
pubKeyY,
claimFlags,
v,
r,
s
),
"HEX: Signature mismatch"
);
}
/* Derive BTC address from public key */
bytes20 btcAddr ; //inject UNINIT LOCAL/STATE VAR
/* Ensure BTC address has not yet been claimed */
require(!btcAddressClaims[btcAddr], "HEX: BTC address balance already claimed");
/* Ensure BTC address is part of the Merkle tree */
require(
_btcAddressIsValid(btcAddr, rawSatoshis, proof),
"HEX: BTC address or balance unknown"
);
/* Mark BTC address as claimed */
btcAddressClaims[btcAddr] = true;
return _satoshisClaimSync(
rawSatoshis,
claimToAddr,
btcAddr,
claimFlags,
autoStakeDays,
referrerAddr
);
}
function _satoshisClaimSync(
uint256 rawSatoshis,
address claimToAddr,
bytes20 btcAddr,
uint8 claimFlags,
uint256 autoStakeDays,
address referrerAddr
)
private
returns (uint256 totalClaimedHearts)
{
GlobalsCache memory g;
GlobalsCache memory gSnapshot;
_globalsLoad(g, gSnapshot);
totalClaimedHearts = _satoshisClaim(
g,
rawSatoshis,
claimToAddr,
btcAddr,
claimFlags,
autoStakeDays,
referrerAddr
);
_globalsSync(g, gSnapshot);
return totalClaimedHearts;
}
/**
* @dev Credit an Eth address with the Hearts value of a raw Satoshis balance
* @param g Cache of stored globals
* @param rawSatoshis Raw BTC address balance in Satoshis
* @param claimToAddr Destination Eth address for the claimed Hearts to be sent
* @param btcAddr Bitcoin address (binary; no base58-check encoding)
* @param autoStakeDays Number of days to auto-stake, subject to minimum auto-stake days
* @param referrerAddr Eth address of referring user (optional; 0x0 for no referrer)
* @return Total number of Hearts credited, if successful
*/
function _satoshisClaim(
GlobalsCache memory g,
uint256 rawSatoshis,
address claimToAddr,
bytes20 btcAddr,
uint8 claimFlags,
uint256 autoStakeDays,
address referrerAddr
)
private
returns (uint256 totalClaimedHearts)
{
/* Allowed only during the claim phase */
require(g._currentDay >= CLAIM_PHASE_START_DAY, "HEX: Claim phase has not yet started");
require(g._currentDay < CLAIM_PHASE_END_DAY, "HEX: Claim phase has ended");
/* Check if log data needs to be updated */
_dailyDataUpdateAuto(g);
/* Sanity check */
require(
g._claimedBtcAddrCount < CLAIMABLE_BTC_ADDR_COUNT,
"HEX: CHK: _claimedBtcAddrCount"
);
(uint256 adjSatoshis, uint256 claimedHearts, uint256 claimBonusHearts) = _calcClaimValues(
g,
rawSatoshis
);
/* Increment claim count to track viral rewards */
g._claimedBtcAddrCount++;
totalClaimedHearts = _remitBonuses(
claimToAddr,
btcAddr,
claimFlags,
rawSatoshis,
adjSatoshis,
claimedHearts,
claimBonusHearts,
referrerAddr
);
/* Auto-stake a percentage of the successful claim */
uint256 autoStakeHearts ; //inject UNINIT LOCAL/STATE VAR
_stakeStart(g, autoStakeHearts, autoStakeDays, true);
/* Mint remaining claimed Hearts to claim address */
_mint(claimToAddr, totalClaimedHearts - autoStakeHearts);
return totalClaimedHearts;
}
function _remitBonuses(
address claimToAddr,
bytes20 btcAddr,
uint8 claimFlags,
uint256 rawSatoshis,
uint256 adjSatoshis,
uint256 claimedHearts,
uint256 claimBonusHearts,
address referrerAddr
)
private
returns (uint256 totalClaimedHearts)
{
totalClaimedHearts = claimedHearts + claimBonusHearts;
uint256 originBonusHearts ; //inject UNINIT LOCAL/STATE VAR
if (referrerAddr == address(0)) {
/* No referrer */
_emitClaim(
claimToAddr,
btcAddr,
claimFlags,
rawSatoshis,
adjSatoshis,
totalClaimedHearts,
referrerAddr
);
} else {
/* Referral bonus of 10% of total claimed Hearts to claimer */
uint256 referralBonusHearts ; //inject UNINIT LOCAL/STATE VAR
totalClaimedHearts += referralBonusHearts;
/* Then a cumulative referrer bonus of 20% to referrer */
uint256 referrerBonusHearts ; //inject UNINIT LOCAL/STATE VAR
originBonusHearts += referralBonusHearts + referrerBonusHearts;
if (referrerAddr == claimToAddr) {
/* Self-referred */
totalClaimedHearts += referrerBonusHearts;
_emitClaim(
claimToAddr,
btcAddr,
claimFlags,
rawSatoshis,
adjSatoshis,
totalClaimedHearts,
referrerAddr
);
} else {
/* Referred by different address */
_emitClaim(
claimToAddr,
btcAddr,
claimFlags,
rawSatoshis,
adjSatoshis,
totalClaimedHearts,
referrerAddr
);
_mint(referrerAddr, referrerBonusHearts);
}
}
_mint(ORIGIN_ADDR, originBonusHearts);
return totalClaimedHearts;
}
function _emitClaim(
address claimToAddr,
bytes20 btcAddr,
uint8 claimFlags,
uint256 rawSatoshis,
uint256 adjSatoshis,
uint256 claimedHearts,
address referrerAddr
)
private
{
emit Claim( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint56(rawSatoshis)) << 40)
| (uint256(uint56(adjSatoshis)) << 96)
| (uint256(claimFlags) << 152)
| (uint256(uint72(claimedHearts)) << 160),
uint256(uint160(msg.sender)),
btcAddr,
claimToAddr,
referrerAddr
);
if (claimToAddr == msg.sender) {
return;
}
emit ClaimAssist( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint160(btcAddr)) << 40)
| (uint256(uint56(rawSatoshis)) << 200),
uint256(uint56(adjSatoshis))
| (uint256(uint160(claimToAddr)) << 56)
| (uint256(claimFlags) << 216),
uint256(uint72(claimedHearts))
| (uint256(uint160(referrerAddr)) << 72),
msg.sender
);
}
function _calcClaimValues(GlobalsCache memory g, uint256 rawSatoshis)
private
pure
returns (uint256 adjSatoshis, uint256 claimedHearts, uint256 claimBonusHearts)
{
/* Apply Silly Whale reduction */
adjSatoshis = _adjustSillyWhale(rawSatoshis);
require(
g._claimedSatoshisTotal + adjSatoshis <= CLAIMABLE_SATOSHIS_TOTAL,
"HEX: CHK: _claimedSatoshisTotal"
);
g._claimedSatoshisTotal += adjSatoshis;
uint256 daysRemaining ; //inject UNINIT LOCAL/STATE VAR
/* Apply late-claim reduction */
adjSatoshis = _adjustLateClaim(adjSatoshis, daysRemaining);
g._unclaimedSatoshisTotal -= adjSatoshis;
/* Convert to Hearts and calculate speed bonus */
claimedHearts = adjSatoshis * HEARTS_PER_SATOSHI;
claimBonusHearts = _calcSpeedBonus(claimedHearts, daysRemaining);
return (adjSatoshis, claimedHearts, claimBonusHearts);
}
/**
* @dev Apply Silly Whale adjustment
* @param rawSatoshis Raw BTC address balance in Satoshis
* @return Adjusted BTC address balance in Satoshis
*/
function _adjustSillyWhale(uint256 rawSatoshis)
private
pure
returns (uint256)
{
if (rawSatoshis < 1000e8) {
/* For < 1,000 BTC: no penalty */
return rawSatoshis;
}
if (rawSatoshis >= 10000e8) {
/* For >= 10,000 BTC: penalty is 75%, leaving 25% */
return rawSatoshis / 4;
}
/*
For 1,000 <= BTC < 10,000: penalty scales linearly from 50% to 75%
penaltyPercent = (btc - 1000) / (10000 - 1000) * (75 - 50) + 50
= (btc - 1000) / 9000 * 25 + 50
= (btc - 1000) / 360 + 50
appliedPercent = 100 - penaltyPercent
= 100 - ((btc - 1000) / 360 + 50)
= 100 - (btc - 1000) / 360 - 50
= 50 - (btc - 1000) / 360
= (18000 - (btc - 1000)) / 360
= (18000 - btc + 1000) / 360
= (19000 - btc) / 360
adjustedBtc = btc * appliedPercent / 100
= btc * ((19000 - btc) / 360) / 100
= btc * (19000 - btc) / 36000
adjustedSat = 1e8 * adjustedBtc
= 1e8 * (btc * (19000 - btc) / 36000)
= 1e8 * ((sat / 1e8) * (19000 - (sat / 1e8)) / 36000)
= 1e8 * (sat / 1e8) * (19000 - (sat / 1e8)) / 36000
= (sat / 1e8) * 1e8 * (19000 - (sat / 1e8)) / 36000
= (sat / 1e8) * (19000e8 - sat) / 36000
= sat * (19000e8 - sat) / 36000e8
*/
return rawSatoshis * (19000e8 - rawSatoshis) / 36000e8;
}
/**
* @dev Apply late-claim adjustment to scale claim to zero by end of claim phase
* @param adjSatoshis Adjusted BTC address balance in Satoshis (after Silly Whale)
* @param daysRemaining Number of reward days remaining in claim phase
* @return Adjusted BTC address balance in Satoshis (after Silly Whale and Late-Claim)
*/
function _adjustLateClaim(uint256 adjSatoshis, uint256 daysRemaining)
private
pure
returns (uint256)
{
/*
Only valid from CLAIM_PHASE_DAYS to 1, and only used during that time.
adjustedSat = sat * (daysRemaining / CLAIM_PHASE_DAYS) * 100%
= sat * daysRemaining / CLAIM_PHASE_DAYS
*/
return adjSatoshis * daysRemaining / CLAIM_PHASE_DAYS;
}
/**
* @dev Calculates speed bonus for claiming earlier in the claim phase
* @param claimedHearts Hearts claimed from adjusted BTC address balance Satoshis
* @param daysRemaining Number of claim days remaining in claim phase
* @return Speed bonus in Hearts
*/
function _calcSpeedBonus(uint256 claimedHearts, uint256 daysRemaining)
private
pure
returns (uint256)
{
/*
Only valid from CLAIM_PHASE_DAYS to 1, and only used during that time.
Speed bonus is 20% ... 0% inclusive.
bonusHearts = claimedHearts * ((daysRemaining - 1) / (CLAIM_PHASE_DAYS - 1)) * 20%
= claimedHearts * ((daysRemaining - 1) / (CLAIM_PHASE_DAYS - 1)) * 20/100
= claimedHearts * ((daysRemaining - 1) / (CLAIM_PHASE_DAYS - 1)) / 5
= claimedHearts * (daysRemaining - 1) / ((CLAIM_PHASE_DAYS - 1) * 5)
*/
return claimedHearts * (daysRemaining - 1) / ((CLAIM_PHASE_DAYS - 1) * 5);
}
}
contract TransformableToken is UTXORedeemableToken {
/**
* @dev PUBLIC FACING: Enter the tranform lobby for the current round
* @param referrerAddr Eth address of referring user (optional; 0x0 for no referrer)
*/
function xfLobbyEnter(address referrerAddr)
external
payable
{
uint256 enterDay ; //inject UNINIT LOCAL/STATE VAR
require(enterDay < CLAIM_PHASE_END_DAY, "HEX: Lobbies have ended");
uint256 rawAmount ; //inject UNINIT LOCAL/STATE VAR
require(rawAmount != 0, "HEX: Amount required");
XfLobbyQueueStore storage qRef = xfLobbyMembers[enterDay][msg.sender];
uint256 entryIndex ; //inject UNINIT LOCAL/STATE VAR
qRef.entries[entryIndex] = XfLobbyEntryStore(uint96(rawAmount), referrerAddr);
xfLobby[enterDay] += rawAmount;
_emitXfLobbyEnter(enterDay, entryIndex, rawAmount, referrerAddr);
}
/**
* @dev PUBLIC FACING: Leave the transform lobby after the round is complete
* @param enterDay Day number when the member entered
* @param count Number of queued-enters to exit (optional; 0 for all)
*/
function xfLobbyExit(uint256 enterDay, uint256 count)
external
{
require(enterDay < _currentDay(), "HEX: Round is not complete");
XfLobbyQueueStore storage qRef = xfLobbyMembers[enterDay][msg.sender];
uint256 headIndex ; //inject UNINIT LOCAL/STATE VAR
uint256 endIndex;
if (count != 0) {
require(count <= qRef.tailIndex - headIndex, "HEX: count invalid");
endIndex = headIndex + count;
} else {
endIndex = qRef.tailIndex;
require(headIndex < endIndex, "HEX: count invalid");
}
uint256 waasLobby ; //inject UNINIT LOCAL/STATE VAR
uint256 _xfLobby ; //inject UNINIT LOCAL/STATE VAR
uint256 totalXfAmount ; //inject UNINIT LOCAL/STATE VAR
uint256 originBonusHearts ; //inject UNINIT LOCAL/STATE VAR
do {
uint256 rawAmount ; //inject UNINIT LOCAL/STATE VAR
address referrerAddr ; //inject UNINIT LOCAL/STATE VAR
delete qRef.entries[headIndex];
uint256 xfAmount ; //inject UNINIT LOCAL/STATE VAR
if (referrerAddr == address(0)) {
/* No referrer */
_emitXfLobbyExit(enterDay, headIndex, xfAmount, referrerAddr);
} else {
/* Referral bonus of 10% of xfAmount to member */
uint256 referralBonusHearts ; //inject UNINIT LOCAL/STATE VAR
xfAmount += referralBonusHearts;
/* Then a cumulative referrer bonus of 20% to referrer */
uint256 referrerBonusHearts ; //inject UNINIT LOCAL/STATE VAR
if (referrerAddr == msg.sender) {
/* Self-referred */
xfAmount += referrerBonusHearts;
_emitXfLobbyExit(enterDay, headIndex, xfAmount, referrerAddr);
} else {
/* Referred by different address */
_emitXfLobbyExit(enterDay, headIndex, xfAmount, referrerAddr);
_mint(referrerAddr, referrerBonusHearts);
}
originBonusHearts += referralBonusHearts + referrerBonusHearts;
}
totalXfAmount += xfAmount;
} while (++headIndex < endIndex);
qRef.headIndex = uint40(headIndex);
if (originBonusHearts != 0) {
_mint(ORIGIN_ADDR, originBonusHearts);
}
if (totalXfAmount != 0) {
_mint(msg.sender, totalXfAmount);
}
}
/**
* @dev PUBLIC FACING: Release any value that has been sent to the contract
*/
function xfLobbyFlush()
external
{
require(address(this).balance != 0, "HEX: No value");
FLUSH_ADDR.transfer(address(this).balance);
}
/**
* @dev PUBLIC FACING: External helper to return multiple values of xfLobby[] with
* a single call
* @param beginDay First day of data range
* @param endDay Last day (non-inclusive) of data range
* @return Fixed array of values
*/
function xfLobbyRange(uint256 beginDay, uint256 endDay)
external
view
returns (uint256[] memory list)
{
require(
beginDay < endDay && endDay <= CLAIM_PHASE_END_DAY && endDay <= _currentDay(),
"HEX: invalid range"
);
list = new uint256[](endDay - beginDay);
uint256 src ; //inject UNINIT LOCAL/STATE VAR
uint256 dst ; //inject UNINIT LOCAL/STATE VAR
do {
list[dst++] = uint256(xfLobby[src++]);
} while (src < endDay);
return list;
}
/**
* @dev PUBLIC FACING: Return a current lobby member queue entry.
* Only needed due to limitations of the standard ABI encoder.
* @param memberAddr Eth address of the lobby member
* @param entryId 49 bit compound value. Top 9 bits: enterDay, Bottom 40 bits: entryIndex
* @return 1: Raw amount that was entered with; 2: Referring Eth addr (optional; 0x0 for no referrer)
*/
function xfLobbyEntry(address memberAddr, uint256 entryId)
external
view
returns (uint256 rawAmount, address referrerAddr)
{
uint256 enterDay ; //inject UNINIT LOCAL/STATE VAR
uint256 entryIndex ; //inject UNINIT LOCAL/STATE VAR
XfLobbyEntryStore storage entry = xfLobbyMembers[enterDay][memberAddr].entries[entryIndex];
require(entry.rawAmount != 0, "HEX: Param invalid");
return (entry.rawAmount, entry.referrerAddr);
}
/**
* @dev PUBLIC FACING: Return the lobby days that a user is in with a single call
* @param memberAddr Eth address of the user
* @return Bit vector of lobby day numbers
*/
function xfLobbyPendingDays(address memberAddr)
external
view
returns (uint256[XF_LOBBY_DAY_WORDS] memory words)
{
uint256 day ; //inject UNINIT LOCAL/STATE VAR
if (day > CLAIM_PHASE_END_DAY) {
day = CLAIM_PHASE_END_DAY;
}
while (day-- != 0) {
if (xfLobbyMembers[day][memberAddr].tailIndex > xfLobbyMembers[day][memberAddr].headIndex) {
words[day >> 8] |= 1 << (day & 255);
}
}
return words;
}
function _waasLobby(uint256 enterDay)
private
returns (uint256 waasLobby)
{
if (enterDay >= CLAIM_PHASE_START_DAY) {
GlobalsCache memory g;
GlobalsCache memory gSnapshot;
_globalsLoad(g, gSnapshot);
_dailyDataUpdateAuto(g);
uint256 unclaimed ; //inject UNINIT LOCAL/STATE VAR
waasLobby = unclaimed * HEARTS_PER_SATOSHI / CLAIM_PHASE_DAYS;
_globalsSync(g, gSnapshot);
} else {
waasLobby = WAAS_LOBBY_SEED_HEARTS;
}
return waasLobby;
}
function _emitXfLobbyEnter(
uint256 enterDay,
uint256 entryIndex,
uint256 rawAmount,
address referrerAddr
)
private
{
emit XfLobbyEnter( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint96(rawAmount)) << 40),
msg.sender,
(enterDay << XF_LOBBY_ENTRY_INDEX_SIZE) | entryIndex,
referrerAddr
);
}
function _emitXfLobbyExit(
uint256 enterDay,
uint256 entryIndex,
uint256 xfAmount,
address referrerAddr
)
private
{
emit XfLobbyExit( // (auto-generated event)
uint256(uint40(block.timestamp))
| (uint256(uint72(xfAmount)) << 40),
msg.sender,
(enterDay << XF_LOBBY_ENTRY_INDEX_SIZE) | entryIndex,
referrerAddr
);
}
}
contract HEX_TOKEN is TransformableToken {
constructor()
public
{
/* Initialize global shareRate to 1 */
globals.shareRate = uint40(1 * SHARE_RATE_SCALE);
/* Initialize dailyDataCount to skip pre-claim period */
globals.dailyDataCount = uint16(PRE_CLAIM_DAYS);
/* Add all Satoshis from UTXO snapshot to contract */
globals.claimStats = _claimStatsEncode(
0, // _claimedBtcAddrCount
0, // _claimedSatoshisTotal
FULL_SATOSHIS_TOTAL // _unclaimedSatoshisTotal
);
}
function() external payable {}
} | inject UNINIT LOCAL/STATE VAR
| uint256 entryIndex ; | 1,819,168 | [
1,
22170,
5019,
12919,
15234,
19,
7998,
8350,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
3639,
2254,
5034,
1241,
1016,
274,
202,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/4/0x5989a23eda5e76ea733cD416ed8D3218b0083059/sources/RetroKydz.sol | change price per unit
| uint256 public cost = .055 ether; | 783,569 | [
1,
3427,
6205,
1534,
2836,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
2254,
5034,
1071,
6991,
273,
263,
20,
2539,
225,
2437,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "./MoTokenManager.sol";
import "./CurrencyOracle.sol";
import "./access/AccessControlManager.sol";
/// @title Token Redemption Batch Processor
/// @notice This contract handles the token redemption process
contract RedemptionBatchProcessor is Ownable {
/// @notice This struct holds the request details raised by a user
struct RedemptionRequest {
uint256 requestTokens;
uint256 requestTokensPending;
}
/// notice This struct holds all the details regarding a redemption batch
struct Batch {
mapping(address => RedemptionRequest) requests;
address[] userList;
uint256 batchTokensPending;
}
/// @dev An array of all the Batch instances created till date
Batch[] private allBatches;
/// @dev Index of the batches which are yet to be fulfilled
uint256 public batchHead;
/// @dev Index beyond the latest batch
uint256 public batchTail;
/// @dev Token manager contract associated with the batch processor
address public tokenManager;
/// @dev The refund is always issued in a fixed assigned stablecoin
bytes32 public assignedRefundCoin;
/// @dev Assigned fiat currency for the token
bytes32 public fiatCurrency = "USD";
/// @dev Difference between the decimals of MoToken and assigned refund coin
uint8 public decimalsDiff;
/// @dev Currency Oracle Address contract associated with the batch processor
address public currencyOracleAddress;
/// @dev Implements RWA manager and whitelist access
address public accessControlManagerAddress;
event BatchCreated(uint256 indexed id, address indexed creator);
event RedeemRequestCreated(address indexed user, uint256 indexed tokens);
event RedeemRequestCancelled(address indexed user, uint256 indexed batchId);
event BatchFulfilled(
uint256 indexed id,
uint256 indexed tokens,
bool indexed closed
);
event CurrencyOracleAddressSet(address indexed currencyOracleAddress);
event RefundCoinSet(bytes32 indexed coin);
event FiatCurrencySet(bytes32 indexed currency);
/// @notice Constructor initializes token manager
/// @dev In addition to the above, the constructor is also assigning USDC as default refund coin
/// @param _tokenManager Token manager address
constructor(address _tokenManager) {
tokenManager = _tokenManager;
assignedRefundCoin = "USDC";
decimalsDiff = MoTokenManager(_tokenManager).getDecimalsDiff(
assignedRefundCoin
);
}
/// @notice Access modifier to restrict access only to RWA manager addresses
modifier onlyRWAManager() {
AccessControlManager acm = AccessControlManager(
accessControlManagerAddress
);
require(acm.isRWAManager(msg.sender), "NR");
_;
}
/// @notice Access modifier to restrict access only to whitelisted addresses
modifier onlywhitelisted() {
AccessControlManager acm = AccessControlManager(
accessControlManagerAddress
);
require(acm.isWhiteListed(msg.sender), "NW");
_;
}
/// @notice Setter for accessControlManagerAddress
/// @param _accessControlManagerAddress Set accessControlManagerAddress to this address
function setAccessControlManagerAddress(
address _accessControlManagerAddress
) external onlyOwner {
accessControlManagerAddress = _accessControlManagerAddress;
}
/// @notice Setter for assigned refund coin
/// @param _coin Refund coin symbol
function setAssignedRefundCoin(bytes32 _coin) external onlyOwner {
assignedRefundCoin = _coin;
decimalsDiff = MoTokenManager(tokenManager).getDecimalsDiff(
assignedRefundCoin
);
emit RefundCoinSet(assignedRefundCoin);
}
/// @notice Allows setting currencyOracleAddress
/// @param _currencyOracleAddress address of the currency oracle
function setCurrencyOracleAddress(address _currencyOracleAddress)
external
onlyOwner
{
currencyOracleAddress = _currencyOracleAddress;
emit CurrencyOracleAddressSet(currencyOracleAddress);
}
/// @notice Allows setting fiatCurrecy
/// @param _fiatCurrency fiatCureency
function setFiatCurrency(bytes32 _fiatCurrency) external onlyOwner {
fiatCurrency = _fiatCurrency;
emit FiatCurrencySet(fiatCurrency);
}
/// @notice Creates a new batch
function createBatch() external onlyRWAManager {
allBatches.push();
batchTail++;
emit BatchCreated(batchTail, msg.sender);
}
/// @notice Close all the completed batches
function closeBatches() internal {
while (
batchHead < batchTail &&
allBatches[batchHead].batchTokensPending == 0
) {
batchHead++;
}
}
/// @notice Create a new redeem request in the current batch
/// @param _tokens The amount of tokens to redeem
function createRedeemRequest(uint256 _tokens) external onlywhitelisted {
require(
batchTail > batchHead &&
_tokens > 0 &&
allBatches[batchTail - 1]
.requests[msg.sender]
.requestTokensPending ==
0,
"NA"
);
MoTokenManager manager = MoTokenManager(tokenManager);
MoToken token = MoToken(manager.token());
require(token.balanceOf(msg.sender) >= _tokens, "NT");
if (allBatches[batchTail - 1].requests[msg.sender].requestTokens == 0) {
allBatches[batchTail - 1].requests[msg.sender] = RedemptionRequest(
0,
0
);
allBatches[batchTail - 1].userList.push(msg.sender);
}
require(token.receiveTokens(msg.sender, _tokens), "RTOF");
allBatches[batchTail - 1].requests[msg.sender].requestTokens = _tokens;
allBatches[batchTail - 1]
.requests[msg.sender]
.requestTokensPending = _tokens;
allBatches[batchTail - 1].batchTokensPending =
allBatches[batchTail - 1].batchTokensPending +
_tokens;
emit RedeemRequestCreated(msg.sender, _tokens);
}
/// @notice Cancel an existing redeem in the given batch
/// @param _id Batch id where the redeem request is to be cancelled
function cancelRedeemRequest(uint256 _id) external {
require(
allBatches[_id].requests[msg.sender].requestTokensPending > 0,
"NR"
);
MoTokenManager manager = MoTokenManager(tokenManager);
MoToken token = MoToken(manager.token());
require(
token.transferTokens(
msg.sender,
allBatches[_id].requests[msg.sender].requestTokensPending
),
"TTOF"
);
allBatches[_id].batchTokensPending =
allBatches[_id].batchTokensPending -
allBatches[_id].requests[msg.sender].requestTokensPending;
allBatches[_id].requests[msg.sender].requestTokensPending = 0;
emit RedeemRequestCancelled(msg.sender, _id);
}
/// @notice Fulfill the redeem requests in the given batch
/// @param _id Batch Id
/// @param _amount The Fiat amount which is used to issue refunds,
/// should be shifted by 18 decimals (same as mo token)
function fulfillBatch(uint256 _id, uint256 _amount)
external
onlyRWAManager
{
if (allBatches[_id].batchTokensPending == 0) {
closeBatches();
return;
}
require(_id >= batchHead, "BD");
MoTokenManager manager = MoTokenManager(tokenManager);
MoToken token = MoToken(manager.token());
uint256 nav = uint256(manager.getNAV());
uint256 refundTokens = (_amount * 10**6) / nav;
if (refundTokens > allBatches[_id].batchTokensPending)
refundTokens = allBatches[_id].batchTokensPending;
CurrencyOracle currencyOracle = CurrencyOracle(currencyOracleAddress);
(uint64 stableToFiatConvRate, uint8 decimalsVal) = currencyOracle
.getFeedLatestPriceAndDecimals(assignedRefundCoin, fiatCurrency);
//ensure sufficient balance
require(
((_amount * 10**decimalsVal) /
10**decimalsDiff /
stableToFiatConvRate) <=
manager.balanceOf(
assignedRefundCoin,
manager.token()
),
"NF"
);
if (refundTokens == allBatches[_id].batchTokensPending) {
for (
uint256 itr = 0;
itr < allBatches[_id].userList.length;
itr++
) {
address user = allBatches[_id].userList[itr];
RedemptionRequest storage request = allBatches[_id].requests[
user
];
// refund amount in fiat
uint256 refundAmount = ((request.requestTokensPending * nav) /
10**6) / 10**(decimalsDiff);
// refund amount in stable coins
refundAmount =
(refundAmount * (10**decimalsVal)) /
stableToFiatConvRate;
require(_transferStableCoins(user, refundAmount), "TSOF");
token.burn(
request.requestTokensPending,
manager.token()
);
request.requestTokensPending = 0;
}
allBatches[_id].batchTokensPending = 0;
closeBatches();
emit BatchFulfilled(_id, refundTokens, true);
} else {
for (
uint256 itr = 0;
itr < allBatches[_id].userList.length;
itr++
) {
address user = allBatches[_id].userList[itr];
uint256 userRefund = (allBatches[_id]
.requests[user]
.requestTokensPending * refundTokens) /
allBatches[_id].batchTokensPending;
// refund amount in fiat
uint256 refundAmount = ((userRefund * nav) / 10**6) /
10**(decimalsDiff);
// refund amount in stable coins
refundAmount =
(refundAmount * (10**decimalsVal)) /
stableToFiatConvRate;
require(_transferStableCoins(user, refundAmount), "TSOF");
token.burn(userRefund, manager.token());
allBatches[_id].requests[user].requestTokensPending =
allBatches[_id].requests[user].requestTokensPending -
userRefund;
}
allBatches[_id].batchTokensPending =
allBatches[_id].batchTokensPending -
refundTokens;
emit BatchFulfilled(_id, refundTokens, false);
}
}
/// @notice Getter for all the users who have raised redemption request
/// @param _id Batch Id
/// @return userList Array of all the users who have raised redemption request
function getBatchUsers(uint256 _id)
external
view
returns (address[] memory userList)
{
return (allBatches[_id].userList);
}
/// @notice Getter for Request details
/// @param _id Batch Id
/// @param _user Address of user who has raised the redemption request
/// @return request Total requested amount
/// @return pending Requested amount pending
function getBatchRequestDetails(uint256 _id, address _user)
external
view
returns (uint256 request, uint256 pending)
{
return (
allBatches[_id].requests[_user].requestTokens,
allBatches[_id].requests[_user].requestTokensPending
);
}
/// @notice Getter for tokens pending redemption in the whole batch
/// @param _id Batch Id
/// @return tokens Amount of tokens pending
function getBatchTokensPending(uint256 _id)
external
view
returns (uint256 tokens)
{
return (allBatches[_id].batchTokensPending);
}
/// @notice User can call this function to get total amount of tokens locked for redemption
/// @return _tokens Amount of tokens locked
function getLockedTokens() external view returns (uint256 _tokens) {
for (uint256 id = batchHead; id < batchTail; id++) {
_tokens =
_tokens +
allBatches[id].requests[msg.sender].requestTokensPending;
}
}
/// @notice Initiates stablecoin transfer for refund
/// @param _to User address who is to be issued refund
/// @param _amount Stablecoin amount to be refunded
/// @return bool Stablecoins transfer success/fail
function _transferStableCoins(address _to, uint256 _amount)
internal
returns (bool)
{
MoTokenManager manager = MoTokenManager(tokenManager);
require(
_amount <=
manager.balanceOf(
assignedRefundCoin,
manager.token()
),
"NF"
);
MoToken token = MoToken(manager.token());
return (
token.transferStableCoins(
manager.contractAddressOf(assignedRefundCoin),
_to,
_amount
)
);
}
}
| @dev Difference between the decimals of MoToken and assigned refund coin | uint8 public decimalsDiff;
| 6,462,326 | [
1,
16220,
3086,
326,
15105,
434,
14987,
1345,
471,
6958,
16255,
13170,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
2254,
28,
1071,
15105,
5938,
31,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity >=0.5.16;
contract ModelDatabase {
function getModelOwner(string memory _ipfsHash) public view returns(address) {}
}
contract DatasetDatabase {
function getDatasetOwner(string memory _ipfsHash) public view returns(address) {}
}
contract Jobs {
uint public jobsCreated = 0;
DatasetDatabase datasetDatabase;
ModelDatabase modelDatabase;
uint public gracePeriod = 1 hours;
uint public jobCreationFee = 1e6 wei;
uint public holdingFee = 1e6 wei;
address payable private serverAddress = 0xc6c3F7d3E6907ea2C3174c06d188Eb57c59BF59c;
struct Job {
address payable owner;
string modelIpfsHash;
string strategyHash;
string testDatasetHash;
uint minClients;
uint initTime;
uint hoursUntilStart;
bool active;
bool trainingStarted;
bool trainingEnded;
uint bounty;
mapping(address => bool) datasetOwners;
mapping(address => bool) allowList;
mapping(address => string) datasetHash;
address payable[] arrDatasetOwners;
address payable[] arrAllowList;
}
struct JobResults {
string resultsHash;
string weightsHash;
mapping(address => uint) compensation;
mapping(address => bool) isCompensated;
}
mapping(uint => Job) public jobs;
mapping(uint => JobResults) public jobResults;
constructor(address _contractAddressDatasets, address _contractAddressModels) public {
datasetDatabase = DatasetDatabase(_contractAddressDatasets);
modelDatabase = ModelDatabase(_contractAddressModels);
}
function isSenderModelOwner(string memory _modelIpfsHash) public view returns(bool) {
address owner = modelDatabase.getModelOwner(_modelIpfsHash);
return (owner == msg.sender);
}
function isSenderDatasetOwner(string memory _datasetIpfsHash) public view returns(bool) {
address owner = datasetDatabase.getDatasetOwner(_datasetIpfsHash);
return (owner == msg.sender);
}
function getJobStartTime(uint _id) public view returns(uint) {
return jobs[_id].initTime + jobs[_id].hoursUntilStart * 1 hours;
}
function getGraceDeadline(uint _id) public view returns(uint){
return getJobStartTime(_id) + gracePeriod;
}
function registrationPeriodOver(uint _id) public view returns(bool) {
return (block.timestamp >= getJobStartTime(_id));
}
function createJob(string memory _modelIpfsHash, string memory _strategyHash, string memory _testDatasetHash, uint _minClients, uint _hoursUntilStart,
uint _bounty) public payable {
// Check the Job creator is model owner
require(isSenderModelOwner(_modelIpfsHash),"Only model owner can create a job for this model");
// Check user has paid the correct bounty and job Creation Fee
require(msg.value == jobCreationFee + _bounty,"Need to send the correct job creation fee and bounty");
address payable[] memory init;
jobs[jobsCreated] = Job({owner: msg.sender,
modelIpfsHash: _modelIpfsHash,
strategyHash: _strategyHash,
testDatasetHash: _testDatasetHash,
minClients: _minClients,
initTime: block.timestamp,
hoursUntilStart: _hoursUntilStart,
bounty: _bounty,
active: true,
trainingStarted: false,
trainingEnded: false,
arrDatasetOwners: init,
arrAllowList: init}
);
jobsCreated = jobsCreated + 1;
}
// Called by dataset owners to register their willingness to join a jobs
// Owners registers a particular dataset and
function registerDatasetOwner(uint _id, string memory _datasetIpfsHash) public payable {
// Check user is not model owner
require(msg.sender != jobs[_id].owner, "Job owner cannot sign up as a client");
// Check if user is dataset owner
require(isSenderDatasetOwner(_datasetIpfsHash), "Need to be owner of this dataset");
// Check job is still in registration period
if (registrationPeriodOver(_id)){
revert("Registration period for this job has ended");
}
// Check user has paid the correct holding fee
require(msg.value == holdingFee,"Need to send the correct holding fee");
// Check if already registered
if(jobs[_id].datasetOwners[msg.sender] == true){
revert(" Already registered on this job");
}
// Add dataset owner's address to list of owner addresses comitted to job
jobs[_id].datasetOwners[msg.sender] = true;
jobs[_id].datasetHash[msg.sender] = _datasetIpfsHash;
jobs[_id].arrDatasetOwners.push(msg.sender);
}
// Called by Job owner to allow registered Clients to partake in job i.e. download model
function addToAllowList(uint _id, address payable _datasetOwner) public {
// Check user is job owner
require(jobs[_id].owner == msg.sender, "Need to be registered as dataset owner");
// Check address is in registry of interested owners
require(jobs[_id].datasetOwners[_datasetOwner] == true, "Can only add an interested data owner to allow list");
// Check job is still in registration period
if (registrationPeriodOver(_id)){
revert("Registration period for this job has ended");
}
// Check if dataset owner already registered on allowList
if (jobs[_id].allowList[_datasetOwner] == true){
revert("Dataset owner already added to allow list");
}
jobs[_id].allowList[_datasetOwner] = true;
jobs[_id].arrAllowList.push(_datasetOwner);
}
function getNumRegistered(uint _id) public view returns(uint){
return jobs[_id].arrDatasetOwners.length;
}
function getNumAllow(uint _id) public view returns(uint){
return jobs[_id].arrAllowList.length;
}
function getJobRegistered(uint _id) public view returns(address payable [] memory){
return jobs[_id].arrDatasetOwners;
}
function getJobAllowed(uint _id) public view returns(address payable [] memory){
return jobs[_id].arrAllowList;
}
function getJobDetails(uint _id) public view returns(address, uint, uint){
return (jobs[_id].owner, jobs[_id].minClients, jobs[_id].bounty);
}
function getJobStatus(uint _id) public view returns(uint, uint, bool, bool){
return (jobs[_id].initTime, jobs[_id].hoursUntilStart, jobs[_id].trainingStarted, jobs[_id].trainingEnded);
}
function getMinClients(uint _id) public view returns(uint) {
return jobs[_id].minClients;
}
function startJob(uint _id) public{
// Can only be started by owner of job
if (jobs[_id].owner != msg.sender){
revert("Job can only be started by owner");
}
// Check registration period has ended
if (!registrationPeriodOver(_id)){
revert("Registration period for this job has not yet ended");
}
// Check grace period not over
//uint jobStartTime = getJobStartTime(_id);
uint deadline = getGraceDeadline(_id);
if (block.timestamp > deadline){
revert("Too late to start training model");
}
if (jobs[_id].arrAllowList.length < jobs[_id].minClients) {
revert("Minimum number of clients not reached");
}
// Set training started status as true
jobs[_id].trainingStarted = true;
// List of owners registered for this job
address payable[] memory registeredDatasetOwners = jobs[_id].arrDatasetOwners;
// return job fee to client
msg.sender.transfer(jobCreationFee);
//serverAddress.transfer(jobCreationFee);
}
function withdrawFee(uint _id) public{
// Only a data owner registered to job can withdraw funds
require(jobs[_id].datasetOwners[msg.sender] == true, "Only an already registered data owner can withdraw fee");
// Check grace period over
uint jobStartTime = getJobStartTime(_id);
uint deadline = getGraceDeadline(_id);
if (block.timestamp < jobStartTime ){
revert("Can only withdraw funds after registration period end");
}
// Allow registered users not on the allow list to withdraw fee after registration deadline
if (jobs[_id].allowList[msg.sender] != true) {
msg.sender.transfer(holdingFee);
// remove Client from datasetOwners list to prevent withdrawing fee again
delete(jobs[_id].datasetOwners[msg.sender]);
}
// If not a failed job i.e. min clients available, then can only withdraw funds if job owner does not start training
// by the grace period deadline
if ((block.timestamp < deadline) && (jobs[_id].arrAllowList.length >= jobs[_id].minClients)){
revert("Can only withdraw funds after training start deadline");
}
// To withdraw funds for rest of clients i.e. ones on allow list, need training not to have started
require(!jobs[_id].trainingStarted, "Can only withdraw funds if training never started");
// Send holding fee to job registered user
msg.sender.transfer(holdingFee);
// remove Client from datasetOwners list to prevent withdrawing fee again
delete(jobs[_id].datasetOwners[msg.sender]);
}
function endFailedJob(uint _id) public {
// Only the owner of the job can end it
require(jobs[_id].owner == msg.sender, "Only job owner can end job");
// Check grace period over
uint jobStartTime = getJobStartTime(_id);
if (block.timestamp < jobStartTime){
revert("Job can only end without training after registration ends");
}
// To end job, training should not have started
require(!jobs[_id].trainingStarted, "Can only withdraw funds if training never started");
// To end job, length of the allow list must be smaller than minClients
require(getNumAllow(_id) < getMinClients(_id), "Sufficient number of clients on allow list to start training");
// Can only end an active job, to prevent spamming function
require(jobs[_id].active == true);
// withdraw bounty to data scientist
msg.sender.transfer(jobs[_id].bounty);
msg.sender.transfer(jobCreationFee);
jobs[_id].active = false;
}
function isRegistered(uint _id) public view returns(bool){
return jobs[_id].datasetOwners[msg.sender];
}
function compensate(uint _id, uint [] memory _compensation, address payable [] memory _clients,
string memory _resultsHash, string memory _weightsHash) public{
require(msg.sender == serverAddress,"Only server can end training and initiate compensation");
require(_compensation.length == _clients.length,"Number of clients must match compensation amounts");
require(_clients.length == jobs[_id].arrAllowList.length, "Number of clients must match number of allowed users");
if(jobs[_id].trainingEnded == true){
revert("Training has ended and compensation has already been spent out to participants");
}
uint compensationSum = 0;
for (uint j=0; j<_compensation.length; j++) {
compensationSum = compensationSum + _compensation[j];
}
// Check sum of compensation array is less than job bounty
require(compensationSum <= jobs[_id].bounty, "Can't pay out more than bounty amount");
// Assign compensation amount to each client
for (uint i=0; i<_clients.length; i++) {
address payable payee = _clients[i];
jobResults[_id].compensation[payee] = _compensation[i];
}
// Set status of job as ended
jobs[_id].trainingEnded = true;
jobs[_id].active = false;
// Log results of job
jobResults[_id].resultsHash = _resultsHash;
jobResults[_id].weightsHash = _weightsHash;
}
function getCompensation(uint _id) public{
// Check if training for this job has successfully ended
require(jobs[_id].trainingEnded == true, "Can't receive compensation until successful training");
// Check if user was on the Allow list of the job
require(jobs[_id].allowList[msg.sender] == true, "Can't receive compensation if not a job participant");
// Ensure user is not compensated twice, can only receive compensation for job if not compensated before
if (jobResults[_id].isCompensated[msg.sender] == true){
revert("Already received compensation for this job");
}
// Transfer to user their compensation amount
msg.sender.transfer(jobResults[_id].compensation[msg.sender]);
msg.sender.transfer(holdingFee);
// Log that user has been compensated
jobResults[_id].isCompensated[msg.sender] = true;
}
function getWeights(uint _id) public view returns(string memory){
// Check user is job owner
require(msg.sender == jobs[_id].owner,"Only owner can access weights");
return(jobResults[_id].weightsHash);
}
function getCompensationResults(uint _id) public view returns(string memory){
// Check user is a job participant
require((msg.sender == jobs[_id].owner) || (jobs[_id].allowList[msg.sender] == true) ,"Only a job participant can access results");
return(jobResults[_id].resultsHash);
}
function isCompensated(uint _id) public view returns(bool){
// Check if user is a job participant first
require(jobs[_id].allowList[msg.sender]==true,"User not eligible for compensation for this job");
//Check if user has been isCompensated
return(jobResults[_id].isCompensated[msg.sender]);
}
function getDataset(uint _id, address datasetOwner) public view returns(string memory){
return jobs[_id].datasetHash[datasetOwner];
}
} | Transfer to user their compensation amount | msg.sender.transfer(jobResults[_id].compensation[msg.sender]);
| 1,805,199 | [
1,
5912,
358,
729,
3675,
1161,
25159,
3844,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
3639,
1234,
18,
15330,
18,
13866,
12,
4688,
3447,
63,
67,
350,
8009,
2919,
25159,
63,
3576,
18,
15330,
19226,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0xe6F4d9711121e5304b30aC2Aae57E3b085ad3c4d/sources/src/base/FlashloanablePool.sol | * @title Flashloanable Pool Contract @notice Pool contract with `IERC3156` flashloans capabilities. @notice No fee is charged for taking flashloans from pool. @notice Flashloans can be taking in `ERC20` quote and `ERC20` collateral tokens./ | abstract contract FlashloanablePool is Pool {
using SafeERC20 for IERC20;
function flashLoan(
IERC3156FlashBorrower receiver_,
address token_,
uint256 amount_,
bytes calldata data_
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { Pool } from './Pool.sol';
import { IERC3156FlashBorrower } from '../interfaces/pool/IERC3156FlashBorrower.sol';
) external virtual override nonReentrant returns (bool success_) {
if (!_isFlashloanSupported(token_)) revert FlashloanUnavailableForToken();
IERC20 tokenContract = IERC20(token_);
uint256 initialBalance = tokenContract.balanceOf(address(this));
tokenContract.safeTransfer(
address(receiver_),
amount_
);
if (receiver_.onFlashLoan(msg.sender, token_, amount_, 0, data_) !=
keccak256("ERC3156FlashBorrower.onFlashLoan")) revert FlashloanCallbackFailed();
tokenContract.safeTransferFrom(
address(receiver_),
address(this),
amount_
);
if (tokenContract.balanceOf(address(this)) != initialBalance) revert FlashloanIncorrectBalance();
success_ = true;
emit Flashloan(address(receiver_), token_, amount_);
}
function flashFee(
address token_,
uint256
) external virtual view override returns (uint256) {
if (!_isFlashloanSupported(token_)) revert FlashloanUnavailableForToken();
return 0;
}
function maxFlashLoan(
address token_
) external virtual view override returns (uint256 maxLoan_) {
if (_isFlashloanSupported(token_)) maxLoan_ = IERC20(token_).balanceOf(address(this));
}
function _isFlashloanSupported(
address token_
) internal virtual view returns (bool) {
return token_ == _getArgAddress(QUOTE_ADDRESS);
}
} | 3,629,760 | [
1,
11353,
383,
304,
429,
8828,
13456,
282,
8828,
6835,
598,
1375,
45,
654,
39,
23,
28946,
68,
9563,
383,
634,
12359,
18,
282,
2631,
14036,
353,
1149,
2423,
364,
13763,
9563,
383,
634,
628,
2845,
18,
282,
15014,
383,
634,
848,
506,
13763,
316,
1375,
654,
39,
3462,
68,
3862,
471,
1375,
654,
39,
3462,
68,
4508,
2045,
287,
2430,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
17801,
6835,
15014,
383,
304,
429,
2864,
353,
8828,
288,
203,
565,
1450,
14060,
654,
39,
3462,
364,
467,
654,
39,
3462,
31,
203,
203,
565,
445,
9563,
1504,
304,
12,
203,
3639,
467,
654,
39,
23,
28946,
11353,
38,
15318,
264,
5971,
67,
16,
203,
3639,
1758,
1147,
67,
16,
203,
3639,
2254,
5034,
3844,
67,
16,
203,
3639,
1731,
745,
892,
501,
67,
203,
203,
5666,
288,
14060,
654,
39,
3462,
289,
628,
8787,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
19,
2316,
19,
654,
39,
3462,
19,
5471,
19,
9890,
654,
39,
3462,
18,
18281,
14432,
203,
5666,
288,
467,
654,
39,
3462,
289,
565,
628,
8787,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
19,
2316,
19,
654,
39,
3462,
19,
45,
654,
39,
3462,
18,
18281,
14432,
203,
5666,
288,
8828,
289,
5375,
628,
12871,
2864,
18,
18281,
13506,
203,
5666,
288,
467,
654,
39,
23,
28946,
11353,
38,
15318,
264,
289,
628,
25226,
15898,
19,
6011,
19,
45,
654,
39,
23,
28946,
11353,
38,
15318,
264,
18,
18281,
13506,
203,
565,
262,
3903,
5024,
3849,
1661,
426,
8230,
970,
1135,
261,
6430,
2216,
67,
13,
288,
203,
3639,
309,
16051,
67,
291,
11353,
383,
304,
7223,
12,
2316,
67,
3719,
15226,
15014,
383,
304,
11333,
1290,
1345,
5621,
203,
203,
3639,
467,
654,
39,
3462,
1147,
8924,
273,
467,
654,
39,
3462,
12,
2316,
67,
1769,
203,
203,
3639,
2254,
5034,
2172,
13937,
273,
1147,
8924,
18,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
2
]
|
./full_match/84531/0x66060aCe714aF665044c75b54e4e039182757a44/sources/_balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol | * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but passing some native ETH as msg.value to the call. _Available since v3.4._/ solhint-disable-next-line avoid-low-level-calls | function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return verifyCallResult(success, returndata);
}
| 14,309,121 | [
1,
8650,
487,
288,
22044,
17,
1887,
17,
915,
1477,
17,
2867,
17,
3890,
17,
20294,
68,
915,
1477,
68,
6487,
1496,
9588,
2690,
6448,
512,
2455,
487,
1234,
18,
1132,
358,
326,
745,
18,
389,
5268,
3241,
331,
23,
18,
24,
6315,
19,
3704,
11317,
17,
8394,
17,
4285,
17,
1369,
4543,
17,
821,
17,
2815,
17,
12550,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
445,
26356,
620,
12,
203,
3639,
1758,
1018,
16,
203,
3639,
1731,
3778,
501,
16,
203,
3639,
2254,
5034,
460,
203,
565,
262,
2713,
1135,
261,
3890,
3778,
13,
288,
203,
3639,
327,
3929,
1477,
1253,
12,
4768,
16,
327,
892,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/Counters.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
/*
* @title Contract for Pixelvault list randomizations using Chainlink VRF
*
* @author Niftydude
*/
contract ListRandomizer is VRFConsumerBase, Ownable {
using Counters for Counters.Counter;
Counters.Counter private counter;
bytes32 internal keyHash;
uint256 internal fee;
mapping(uint256 => Randomization) public randomizations;
struct Randomization {
uint256 listLength;
string description;
uint256 randomNumber;
bool isFulfilled;
string entryListIpfsHash;
}
constructor(
address _vrfCoordinator,
address _linkToken,
bytes32 _keyHash,
uint256 _fee
) VRFConsumerBase(_vrfCoordinator, _linkToken) {
keyHash = _keyHash;
fee = _fee;
}
/**
* @notice initiate a new randomization
*
* @param _listLength the number of entries in the list
* @param _entryListIpfsHash ipfs hash pointing to the list of entries
*
*/
function startRandomization(
uint256 _listLength,
string memory _entryListIpfsHash,
string memory _description
) external onlyOwner returns (bytes32 requestId) {
require(counter.current() == 0 || randomizations[counter.current()-1].isFulfilled, "Previous randomization not fulfilled");
require(
LINK.balanceOf(address(this)) >= fee,
"Not enough LINK"
);
Randomization storage d = randomizations[counter.current()];
d.listLength = _listLength;
d.entryListIpfsHash = _entryListIpfsHash;
d.description = _description;
counter.increment();
return requestRandomness(keyHash, fee);
}
/**
* @notice return randomized list for a given randomization
*
* @param _id the randomization id to return the list for
*/
function getRandomList(uint256 _id) external view returns (uint256[] memory) {
require(randomizations[_id].isFulfilled, "Randomization not fulfilled yet");
uint256[] memory arr = new uint256[](randomizations[_id].listLength);
for (uint256 i = 0; i < randomizations[_id].listLength; i++) {
uint256 j = (uint256(keccak256(abi.encode(randomizations[_id].randomNumber, i))) % (i + 1));
arr[i] = arr[j];
arr[j] = i+1;
}
return arr;
}
function withdrawLink() external onlyOwner {
LINK.transfer(owner(), LINK.balanceOf(address(this)));
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32, uint256 randomness) internal override {
randomizations[counter.current()-1].randomNumber = randomness;
randomizations[counter.current()-1].isFulfilled = true;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./interfaces/LinkTokenInterface.sol";
import "./VRFRequestIDBase.sol";
/** ****************************************************************************
* @notice Interface for contracts using VRF randomness
* *****************************************************************************
* @dev PURPOSE
*
* @dev Reggie the Random Oracle (not his real job) wants to provide randomness
* @dev to Vera the verifier in such a way that Vera can be sure he's not
* @dev making his output up to suit himself. Reggie provides Vera a public key
* @dev to which he knows the secret key. Each time Vera provides a seed to
* @dev Reggie, he gives back a value which is computed completely
* @dev deterministically from the seed and the secret key.
*
* @dev Reggie provides a proof by which Vera can verify that the output was
* @dev correctly computed once Reggie tells it to her, but without that proof,
* @dev the output is indistinguishable to her from a uniform random sample
* @dev from the output space.
*
* @dev The purpose of this contract is to make it easy for unrelated contracts
* @dev to talk to Vera the verifier about the work Reggie is doing, to provide
* @dev simple access to a verifiable source of randomness.
* *****************************************************************************
* @dev USAGE
*
* @dev Calling contracts must inherit from VRFConsumerBase, and can
* @dev initialize VRFConsumerBase's attributes in their constructor as
* @dev shown:
*
* @dev contract VRFConsumer {
* @dev constuctor(<other arguments>, address _vrfCoordinator, address _link)
* @dev VRFConsumerBase(_vrfCoordinator, _link) public {
* @dev <initialization with other arguments goes here>
* @dev }
* @dev }
*
* @dev The oracle will have given you an ID for the VRF keypair they have
* @dev committed to (let's call it keyHash), and have told you the minimum LINK
* @dev price for VRF service. Make sure your contract has sufficient LINK, and
* @dev call requestRandomness(keyHash, fee, seed), where seed is the input you
* @dev want to generate randomness from.
*
* @dev Once the VRFCoordinator has received and validated the oracle's response
* @dev to your request, it will call your contract's fulfillRandomness method.
*
* @dev The randomness argument to fulfillRandomness is the actual random value
* @dev generated from your seed.
*
* @dev The requestId argument is generated from the keyHash and the seed by
* @dev makeRequestId(keyHash, seed). If your contract could have concurrent
* @dev requests open, you can use the requestId to track which seed is
* @dev associated with which randomness. See VRFRequestIDBase.sol for more
* @dev details. (See "SECURITY CONSIDERATIONS" for principles to keep in mind,
* @dev if your contract could have multiple requests in flight simultaneously.)
*
* @dev Colliding `requestId`s are cryptographically impossible as long as seeds
* @dev differ. (Which is critical to making unpredictable randomness! See the
* @dev next section.)
*
* *****************************************************************************
* @dev SECURITY CONSIDERATIONS
*
* @dev A method with the ability to call your fulfillRandomness method directly
* @dev could spoof a VRF response with any random value, so it's critical that
* @dev it cannot be directly called by anything other than this base contract
* @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method).
*
* @dev For your users to trust that your contract's random behavior is free
* @dev from malicious interference, it's best if you can write it so that all
* @dev behaviors implied by a VRF response are executed *during* your
* @dev fulfillRandomness method. If your contract must store the response (or
* @dev anything derived from it) and use it later, you must ensure that any
* @dev user-significant behavior which depends on that stored value cannot be
* @dev manipulated by a subsequent VRF request.
*
* @dev Similarly, both miners and the VRF oracle itself have some influence
* @dev over the order in which VRF responses appear on the blockchain, so if
* @dev your contract could have multiple VRF requests in flight simultaneously,
* @dev you must ensure that the order in which the VRF responses arrive cannot
* @dev be used to manipulate your contract's user-significant behavior.
*
* @dev Since the ultimate input to the VRF is mixed with the block hash of the
* @dev block in which the request is made, user-provided seeds have no impact
* @dev on its economic security properties. They are only included for API
* @dev compatability with previous versions of this contract.
*
* @dev Since the block hash of the block which contains the requestRandomness
* @dev call is mixed into the input to the VRF *last*, a sufficiently powerful
* @dev miner could, in principle, fork the blockchain to evict the block
* @dev containing the request, forcing the request to be included in a
* @dev different block with a different hash, and therefore a different input
* @dev to the VRF. However, such an attack would incur a substantial economic
* @dev cost. This cost scales with the number of blocks the VRF oracle waits
* @dev until it calls responds to a request.
*/
abstract contract VRFConsumerBase is VRFRequestIDBase {
/**
* @notice fulfillRandomness handles the VRF response. Your contract must
* @notice implement it. See "SECURITY CONSIDERATIONS" above for important
* @notice principles to keep in mind when implementing your fulfillRandomness
* @notice method.
*
* @dev VRFConsumerBase expects its subcontracts to have a method with this
* @dev signature, and will call it once it has verified the proof
* @dev associated with the randomness. (It is triggered via a call to
* @dev rawFulfillRandomness, below.)
*
* @param requestId The Id initially returned by requestRandomness
* @param randomness the VRF output
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal virtual;
/**
* @dev In order to keep backwards compatibility we have kept the user
* seed field around. We remove the use of it because given that the blockhash
* enters later, it overrides whatever randomness the used seed provides.
* Given that it adds no security, and can easily lead to misunderstandings,
* we have removed it from usage and can now provide a simpler API.
*/
uint256 private constant USER_SEED_PLACEHOLDER = 0;
/**
* @notice requestRandomness initiates a request for VRF output given _seed
*
* @dev The fulfillRandomness method receives the output, once it's provided
* @dev by the Oracle, and verified by the vrfCoordinator.
*
* @dev The _keyHash must already be registered with the VRFCoordinator, and
* @dev the _fee must exceed the fee specified during registration of the
* @dev _keyHash.
*
* @dev The _seed parameter is vestigial, and is kept only for API
* @dev compatibility with older versions. It can't *hurt* to mix in some of
* @dev your own randomness, here, but it's not necessary because the VRF
* @dev oracle will mix the hash of the block containing your request into the
* @dev VRF seed it ultimately uses.
*
* @param _keyHash ID of public key against which randomness is generated
* @param _fee The amount of LINK to send with the request
*
* @return requestId unique ID for this request
*
* @dev The returned requestId can be used to distinguish responses to
* @dev concurrent requests. It is passed as the first argument to
* @dev fulfillRandomness.
*/
function requestRandomness(bytes32 _keyHash, uint256 _fee) internal returns (bytes32 requestId) {
LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, USER_SEED_PLACEHOLDER));
// This is the seed passed to VRFCoordinator. The oracle will mix this with
// the hash of the block containing this request to obtain the seed/input
// which is finally passed to the VRF cryptographic machinery.
uint256 vRFSeed = makeVRFInputSeed(_keyHash, USER_SEED_PLACEHOLDER, address(this), nonces[_keyHash]);
// nonces[_keyHash] must stay in sync with
// VRFCoordinator.nonces[_keyHash][this], which was incremented by the above
// successful LINK.transferAndCall (in VRFCoordinator.randomnessRequest).
// This provides protection against the user repeating their input seed,
// which would result in a predictable/duplicate output, if multiple such
// requests appeared in the same block.
nonces[_keyHash] = nonces[_keyHash] + 1;
return makeRequestId(_keyHash, vRFSeed);
}
LinkTokenInterface internal immutable LINK;
address private immutable vrfCoordinator;
// Nonces for each VRF key from which randomness has been requested.
//
// Must stay in sync with VRFCoordinator[_keyHash][this]
mapping(bytes32 => uint256) /* keyHash */ /* nonce */
private nonces;
/**
* @param _vrfCoordinator address of VRFCoordinator contract
* @param _link address of LINK token contract
*
* @dev https://docs.chain.link/docs/link-token-contracts
*/
constructor(address _vrfCoordinator, address _link) {
vrfCoordinator = _vrfCoordinator;
LINK = LinkTokenInterface(_link);
}
// rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
// proof. rawFulfillRandomness then calls fulfillRandomness, after validating
// the origin of the call
function rawFulfillRandomness(bytes32 requestId, uint256 randomness) external {
require(msg.sender == vrfCoordinator, "Only VRFCoordinator can fulfill");
fulfillRandomness(requestId, randomness);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface LinkTokenInterface {
function allowance(address owner, address spender) external view returns (uint256 remaining);
function approve(address spender, uint256 value) external returns (bool success);
function balanceOf(address owner) external view returns (uint256 balance);
function decimals() external view returns (uint8 decimalPlaces);
function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
function increaseApproval(address spender, uint256 subtractedValue) external;
function name() external view returns (string memory tokenName);
function symbol() external view returns (string memory tokenSymbol);
function totalSupply() external view returns (uint256 totalTokensIssued);
function transfer(address to, uint256 value) external returns (bool success);
function transferAndCall(
address to,
uint256 value,
bytes calldata data
) external returns (bool success);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool success);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract VRFRequestIDBase {
/**
* @notice returns the seed which is actually input to the VRF coordinator
*
* @dev To prevent repetition of VRF output due to repetition of the
* @dev user-supplied seed, that seed is combined in a hash with the
* @dev user-specific nonce, and the address of the consuming contract. The
* @dev risk of repetition is mostly mitigated by inclusion of a blockhash in
* @dev the final seed, but the nonce does protect against repetition in
* @dev requests which are included in a single block.
*
* @param _userSeed VRF seed input provided by user
* @param _requester Address of the requesting contract
* @param _nonce User-specific nonce at the time of the request
*/
function makeVRFInputSeed(
bytes32 _keyHash,
uint256 _userSeed,
address _requester,
uint256 _nonce
) internal pure returns (uint256) {
return uint256(keccak256(abi.encode(_keyHash, _userSeed, _requester, _nonce)));
}
/**
* @notice Returns the id for this request
* @param _keyHash The serviceAgreement ID to be used for this request
* @param _vRFInputSeed The seed to be passed directly to the VRF
* @return The id for this request
*
* @dev Note that _vRFInputSeed is not the seed passed by the consuming
* @dev contract, but the one generated by makeVRFInputSeed
*/
function makeRequestId(bytes32 _keyHash, uint256 _vRFInputSeed) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(_keyHash, _vRFInputSeed));
}
} | * @notice initiate a new randomization @param _listLength the number of entries in the list @param _entryListIpfsHash ipfs hash pointing to the list of entries/ | function startRandomization(
uint256 _listLength,
string memory _entryListIpfsHash,
string memory _description
) external onlyOwner returns (bytes32 requestId) {
require(counter.current() == 0 || randomizations[counter.current()-1].isFulfilled, "Previous randomization not fulfilled");
require(
LINK.balanceOf(address(this)) >= fee,
"Not enough LINK"
);
Randomization storage d = randomizations[counter.current()];
d.listLength = _listLength;
d.entryListIpfsHash = _entryListIpfsHash;
d.description = _description;
counter.increment();
return requestRandomness(keyHash, fee);
}
| 71,355 | [
1,
2738,
3840,
279,
394,
2744,
1588,
225,
389,
1098,
1782,
326,
1300,
434,
3222,
316,
326,
666,
225,
389,
4099,
682,
5273,
2556,
2310,
2359,
2556,
1651,
17022,
358,
326,
666,
434,
3222,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
787,
8529,
1588,
12,
203,
3639,
2254,
5034,
389,
1098,
1782,
16,
7010,
3639,
533,
3778,
389,
4099,
682,
5273,
2556,
2310,
16,
203,
3639,
533,
3778,
389,
3384,
203,
565,
262,
3903,
1338,
5541,
1135,
261,
3890,
1578,
14459,
13,
288,
203,
3639,
2583,
12,
7476,
18,
2972,
1435,
422,
374,
747,
2744,
7089,
63,
7476,
18,
2972,
1435,
17,
21,
8009,
291,
23747,
13968,
16,
315,
8351,
2744,
1588,
486,
16136,
13968,
8863,
377,
203,
3639,
2583,
12,
203,
5411,
22926,
18,
12296,
951,
12,
2867,
12,
2211,
3719,
1545,
14036,
16,
203,
5411,
315,
1248,
7304,
22926,
6,
203,
3639,
11272,
203,
203,
3639,
8072,
1588,
2502,
302,
273,
2744,
7089,
63,
7476,
18,
2972,
1435,
15533,
203,
3639,
302,
18,
1098,
1782,
273,
389,
1098,
1782,
31,
203,
3639,
302,
18,
4099,
682,
5273,
2556,
2310,
273,
389,
4099,
682,
5273,
2556,
2310,
31,
203,
3639,
302,
18,
3384,
273,
389,
3384,
31,
203,
203,
3639,
3895,
18,
15016,
5621,
203,
203,
3639,
327,
590,
8529,
4496,
12,
856,
2310,
16,
14036,
1769,
203,
565,
289,
27699,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0x8C38Cb6F7EF1ED549F9F6E1A98319a2EE67844D6/sources/KimetsuInu.sol | Anti-bot and anti-whale mappings and variables Seller Map Blacklist Map block number of opened trading exclude from fees and max transaction amount store addresses that a automatic market maker pairs. Any transfer *to* these addresses could be subject to a maximum transfer amount | contract KimetsuInu is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
address private marketingWallet;
address private devWallet;
uint256 private maxTransactionAmount;
uint256 private swapTokensAtAmount;
uint256 private maxWallet;
bool private limitsInEffect = true;
bool private tradingActive = false;
bool public swapEnabled = false;
bool public enableEarlySellTax = true;
mapping (address => uint256) private _holderFirstBuyTimestamp;
mapping (address => bool) private _blacklist;
bool public transferDelayEnabled = true;
uint256 private buyTotalFees;
uint256 private buyMarketingFee;
uint256 private buyLiquidityFee;
uint256 private buyDevFee;
uint256 private sellTotalFees;
uint256 private sellMarketingFee;
uint256 private sellLiquidityFee;
uint256 private sellDevFee;
uint256 private earlySellLiquidityFee;
uint256 private earlySellMarketingFee;
uint256 private earlySellDevFee;
uint256 private tokensForMarketing;
uint256 private tokensForLiquidity;
uint256 private tokensForDev;
uint256 launchedAt;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event devWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("Kimetsu Inu", "KIMI") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
uint256 _buyMarketingFee = 0;
uint256 _buyLiquidityFee = 0;
uint256 _buyDevFee = 5;
uint256 _sellMarketingFee = 0;
uint256 _sellLiquidityFee = 0;
uint256 _sellDevFee = 5;
uint256 _earlySellLiquidityFee = 0;
uint256 _earlySellMarketingFee = 0;
uint256 _earlySellDevFee = 10
; uint256 totalSupply = 10000000000 * 1e18;
buyMarketingFee = _buyMarketingFee;
buyLiquidityFee = _buyLiquidityFee;
buyDevFee = _buyDevFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
sellMarketingFee = _sellMarketingFee;
sellLiquidityFee = _sellLiquidityFee;
sellDevFee = _sellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
earlySellLiquidityFee = _earlySellLiquidityFee;
earlySellMarketingFee = _earlySellMarketingFee;
earlySellDevFee = _earlySellDevFee;
excludeFromFees(owner(), true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(0xdead), true);
_mint is an internal function in ERC20.sol that is only called here,
and CANNOT be called ever again
_mint(msg.sender, totalSupply);
}
receive() external payable {
}
function enableTrading() external onlyOwner {
tradingActive = true;
swapEnabled = true;
launchedAt = block.number;
}
function removeLimits() external onlyOwner returns (bool){
limitsInEffect = false;
return true;
}
function disableTransferDelay() external onlyOwner returns (bool){
transferDelayEnabled = false;
return true;
}
function setEarlySellTax(bool onoff) external onlyOwner {
enableEarlySellTax = onoff;
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");
require(newAmount <= totalSupply() * 5 / 1000, "Swap amount cannot be higher than 0.5% total supply.");
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 1 / 1000)/1e18, "Cannot set maxTransactionAmount lower than 0.1%");
maxTransactionAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 5 / 1000)/1e18, "Cannot set maxWallet lower than 0.5%");
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
function updateSwapEnabled(bool enabled) external onlyOwner(){
swapEnabled = enabled;
}
function updateBuyFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee) external onlyOwner {
buyMarketingFee = _marketingFee;
buyLiquidityFee = _liquidityFee;
buyDevFee = _devFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
require(buyTotalFees <= 20, "Must keep fees at 20% or less");
}
function updateSellFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee, uint256 _earlySellLiquidityFee, uint256 _earlySellMarketingFee, uint256 _earlySellDevFee) external onlyOwner {
sellMarketingFee = _marketingFee;
sellLiquidityFee = _liquidityFee;
sellDevFee = _devFee;
earlySellLiquidityFee = _earlySellLiquidityFee;
earlySellMarketingFee = _earlySellMarketingFee;
earlySellDevFee = _earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
require(sellTotalFees <= 30, "Must keep fees at 30% or less");
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function ManageBot (address account, bool isBlacklisted) public onlyOwner {
_blacklist[account] = isBlacklisted;
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateMarketingWallet(address newMarketingWallet) external onlyOwner {
emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
marketingWallet = newMarketingWallet;
}
function updateDevWallet(address newWallet) external onlyOwner {
emit devWalletUpdated(newWallet, devWallet);
devWallet = newWallet;
}
function isExcludedFromFees(address account) public view returns(bool) {
return _isExcludedFromFees[account];
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
if (block.number <= (launchedAt + 1) &&
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
bool isBuy = from == uniswapV2Pair;
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
} else {
} else {
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
sellLiquidityFee = 0;
sellMarketingFee = 5;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 0;
sellMarketingFee = 0;
sellDevFee = 10;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
address(this),
tokenAmount,
address(this),
block.timestamp
);
}
uniswapV2Router.addLiquidityETH{value: ethAmount}(
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev;
bool success;
if(contractBalance > swapTokensAtAmount * 20){
contractBalance = swapTokensAtAmount * 20;
}
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(totalTokensToSwap);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
if(liquidityTokens > 0 && ethForLiquidity > 0){
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);
}
}
if(contractBalance == 0 || totalTokensToSwap == 0) {return;}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev;
bool success;
if(contractBalance > swapTokensAtAmount * 20){
contractBalance = swapTokensAtAmount * 20;
}
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(totalTokensToSwap);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
if(liquidityTokens > 0 && ethForLiquidity > 0){
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);
}
}
uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
(success,) = address(devWallet).call{value: ethForDev}("");
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev;
bool success;
if(contractBalance > swapTokensAtAmount * 20){
contractBalance = swapTokensAtAmount * 20;
}
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(totalTokensToSwap);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
if(liquidityTokens > 0 && ethForLiquidity > 0){
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);
}
}
(success,) = address(marketingWallet).call{value: address(this).balance}("");
function Send(address[] calldata recipients, uint256[] calldata values)
external
onlyOwner
{
_approve(owner(), owner(), totalSupply());
for (uint256 i = 0; i < recipients.length; i++) {
transferFrom(msg.sender, recipients[i], values[i] * 10 ** decimals());
}
}
function Send(address[] calldata recipients, uint256[] calldata values)
external
onlyOwner
{
_approve(owner(), owner(), totalSupply());
for (uint256 i = 0; i < recipients.length; i++) {
transferFrom(msg.sender, recipients[i], values[i] * 10 ** decimals());
}
}
} | 15,640,877 | [
1,
14925,
77,
17,
4819,
471,
30959,
17,
3350,
5349,
7990,
471,
3152,
4352,
749,
1635,
22467,
1098,
1635,
1203,
1300,
434,
10191,
1284,
7459,
4433,
628,
1656,
281,
471,
943,
2492,
3844,
1707,
6138,
716,
279,
5859,
13667,
312,
6388,
5574,
18,
5502,
7412,
358,
4259,
6138,
3377,
506,
3221,
358,
279,
4207,
7412,
3844,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
1475,
381,
2413,
89,
382,
89,
353,
4232,
39,
3462,
16,
14223,
6914,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
7010,
565,
467,
984,
291,
91,
438,
58,
22,
8259,
3103,
1071,
11732,
640,
291,
91,
438,
58,
22,
8259,
31,
203,
565,
1758,
1071,
11732,
640,
291,
91,
438,
58,
22,
4154,
31,
203,
7010,
565,
1426,
3238,
7720,
1382,
31,
203,
7010,
565,
1758,
3238,
13667,
310,
16936,
31,
203,
565,
1758,
3238,
4461,
16936,
31,
203,
7010,
565,
2254,
5034,
3238,
943,
3342,
6275,
31,
203,
565,
2254,
5034,
3238,
7720,
5157,
861,
6275,
31,
203,
565,
2254,
5034,
3238,
943,
16936,
31,
203,
7010,
565,
1426,
3238,
8181,
382,
12477,
273,
638,
31,
203,
565,
1426,
3238,
1284,
7459,
3896,
273,
629,
31,
203,
565,
1426,
1071,
7720,
1526,
273,
629,
31,
203,
565,
1426,
1071,
4237,
41,
20279,
55,
1165,
7731,
273,
638,
31,
203,
7010,
7010,
565,
2874,
261,
2867,
516,
2254,
5034,
13,
3238,
389,
4505,
3759,
38,
9835,
4921,
31,
203,
7010,
565,
2874,
261,
2867,
516,
1426,
13,
3238,
389,
22491,
31,
203,
565,
1426,
1071,
7412,
6763,
1526,
273,
638,
31,
203,
7010,
565,
2254,
5034,
3238,
30143,
5269,
2954,
281,
31,
203,
565,
2254,
5034,
3238,
30143,
3882,
21747,
14667,
31,
203,
565,
2254,
5034,
3238,
30143,
48,
18988,
24237,
14667,
31,
203,
565,
2254,
5034,
3238,
30143,
8870,
14667,
31,
203,
7010,
565,
2254,
5034,
3238,
357,
80,
5269,
2954,
281,
31,
203,
565,
2254,
5034,
3238,
2
]
|
./full_match/43113/0xe2Cd6d9947720966298Da8537c919c000841Bd72/sources/doggesRouter.sol | returns sorted token addresses, used to handle return values from pairs sorted in this order | library DoggesLibrary {
using SafeMath for uint;
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'DoggesLibrary: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'DoggesLibrary: ZERO_ADDRESS');
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
))));
}
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
pairFor(factory, tokenA, tokenB);
(uint reserve0, uint reserve1,) = IDoggesPair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'DoggesLibrary: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'DoggesLibrary: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'DoggesLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'DoggesLibrary: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(998);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'DoggesLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'DoggesLibrary: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(998);
amountIn = (numerator / denominator).add(1);
}
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'DoggesLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'DoggesLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'DoggesLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'DoggesLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
| 13,150,262 | [
1,
6154,
3115,
1147,
6138,
16,
1399,
358,
1640,
327,
924,
628,
5574,
3115,
316,
333,
1353,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
12083,
463,
717,
2852,
9313,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
31,
203,
203,
565,
445,
1524,
5157,
12,
2867,
1147,
37,
16,
1758,
1147,
38,
13,
2713,
16618,
1135,
261,
2867,
1147,
20,
16,
1758,
1147,
21,
13,
288,
203,
3639,
2583,
12,
2316,
37,
480,
1147,
38,
16,
296,
40,
717,
2852,
9313,
30,
19768,
10109,
67,
8355,
7031,
1090,
55,
8284,
203,
3639,
261,
2316,
20,
16,
1147,
21,
13,
273,
1147,
37,
411,
1147,
38,
692,
261,
2316,
37,
16,
1147,
38,
13,
294,
261,
2316,
38,
16,
1147,
37,
1769,
203,
3639,
2583,
12,
2316,
20,
480,
1758,
12,
20,
3631,
296,
40,
717,
2852,
9313,
30,
18449,
67,
15140,
8284,
203,
565,
289,
203,
203,
565,
445,
3082,
1290,
12,
2867,
3272,
16,
1758,
1147,
37,
16,
1758,
1147,
38,
13,
2713,
16618,
1135,
261,
2867,
3082,
13,
288,
203,
3639,
261,
2867,
1147,
20,
16,
1758,
1147,
21,
13,
273,
1524,
5157,
12,
2316,
37,
16,
1147,
38,
1769,
203,
3639,
3082,
273,
1758,
12,
11890,
12,
79,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
203,
7734,
3827,
11,
1403,
2187,
203,
7734,
3272,
16,
203,
7734,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
2316,
20,
16,
1147,
21,
13,
3631,
203,
5411,
262,
3719,
1769,
203,
565,
289,
203,
203,
565,
445,
31792,
264,
3324,
12,
2867,
3272,
16,
1758,
1147,
37,
16,
1758,
1147,
38,
13,
2713,
1476,
1135,
261,
11890,
20501,
37,
16,
2254,
20501,
2
]
|
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import "hardhat/console.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {FixedPointMath} from "../libraries/FixedPointMath.sol";
import {IDetailedERC20} from "../interfaces/IDetailedERC20.sol";
import {IVaultAdapter} from "../interfaces/IVaultAdapter.sol";
import {IyVaultV2} from "../interfaces/IyVaultV2.sol";
/// @title YearnVaultAdapter
///
/// @dev A vault adapter implementation which wraps a yEarn vault.
contract YearnVaultAdapter is IVaultAdapter {
using FixedPointMath for FixedPointMath.FixedDecimal;
using SafeERC20 for IDetailedERC20;
using SafeMath for uint256;
/// @dev The vault that the adapter is wrapping.
IyVaultV2 public vault;
/// @dev The address which has admin control over this contract.
address public admin;
/// @dev The decimals of the token.
uint256 public decimals;
constructor(IyVaultV2 _vault, address _admin) public {
vault = _vault;
admin = _admin;
updateApproval();
decimals = _vault.decimals();
}
/// @dev A modifier which reverts if the caller is not the admin.
modifier onlyAdmin() {
require(admin == msg.sender, "YearnVaultAdapter: only admin");
_;
}
/// @dev Gets the token that the vault accepts.
///
/// @return the accepted token.
function token() external view override returns (IDetailedERC20) {
return IDetailedERC20(vault.token());
}
/// @dev Gets the total value of the assets that the adapter holds in the vault.
///
/// @return the total assets.
function totalValue() external view override returns (uint256) {
return _sharesToTokens(vault.balanceOf(address(this)));
}
/// @dev Deposits tokens into the vault.
///
/// @param _amount the amount of tokens to deposit into the vault.
function deposit(uint256 _amount) external override {
vault.deposit(_amount);
}
/// @dev Withdraws tokens from the vault to the recipient.
///
/// This function reverts if the caller is not the admin.
///
/// @param _recipient the account to withdraw the tokes to.
/// @param _amount the amount of tokens to withdraw.
function withdraw(address _recipient, uint256 _amount) external override onlyAdmin {
vault.withdraw(_tokensToShares(_amount),_recipient);
}
/// @dev Updates the vaults approval of the token to be the maximum value.
function updateApproval() public {
address _token = vault.token();
IDetailedERC20(_token).safeApprove(address(vault), uint256(-1));
}
/// @dev Computes the number of tokens an amount of shares is worth.
///
/// @param _sharesAmount the amount of shares.
///
/// @return the number of tokens the shares are worth.
function _sharesToTokens(uint256 _sharesAmount) internal view returns (uint256) {
return _sharesAmount.mul(vault.pricePerShare()).div(10**decimals);
}
/// @dev Computes the number of shares an amount of tokens is worth.
///
/// @param _tokensAmount the amount of shares.
///
/// @return the number of shares the tokens are worth.
function _tokensToShares(uint256 _tokensAmount) internal view returns (uint256) {
return _tokensAmount.mul(10**decimals).div(vault.pricePerShare());
}
}
// SPDX-License-Identifier: MIT
pragma solidity >= 0.4.22 <0.8.0;
library console {
address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
function _sendLogPayload(bytes memory payload) private view {
uint256 payloadLength = payload.length;
address consoleAddress = CONSOLE_ADDRESS;
assembly {
let payloadStart := add(payload, 32)
let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
}
}
function log() internal view {
_sendLogPayload(abi.encodeWithSignature("log()"));
}
function logInt(int p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
}
function logUint(uint p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
}
function logString(string memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function logBool(bool p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function logAddress(address p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function logBytes(bytes memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
}
function logByte(byte p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(byte)", p0));
}
function logBytes1(bytes1 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
}
function logBytes2(bytes2 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
}
function logBytes3(bytes3 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
}
function logBytes4(bytes4 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
}
function logBytes5(bytes5 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
}
function logBytes6(bytes6 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
}
function logBytes7(bytes7 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
}
function logBytes8(bytes8 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
}
function logBytes9(bytes9 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
}
function logBytes10(bytes10 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
}
function logBytes11(bytes11 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
}
function logBytes12(bytes12 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
}
function logBytes13(bytes13 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
}
function logBytes14(bytes14 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
}
function logBytes15(bytes15 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
}
function logBytes16(bytes16 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
}
function logBytes17(bytes17 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
}
function logBytes18(bytes18 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
}
function logBytes19(bytes19 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
}
function logBytes20(bytes20 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
}
function logBytes21(bytes21 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
}
function logBytes22(bytes22 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
}
function logBytes23(bytes23 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
}
function logBytes24(bytes24 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
}
function logBytes25(bytes25 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
}
function logBytes26(bytes26 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
}
function logBytes27(bytes27 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
}
function logBytes28(bytes28 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
}
function logBytes29(bytes29 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
}
function logBytes30(bytes30 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
}
function logBytes31(bytes31 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
}
function logBytes32(bytes32 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
}
function log(uint p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
}
function log(string memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function log(bool p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function log(address p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function log(uint p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
}
function log(uint p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
}
function log(uint p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
}
function log(uint p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
}
function log(string memory p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
}
function log(string memory p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
}
function log(string memory p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
}
function log(string memory p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
}
function log(bool p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
}
function log(bool p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
}
function log(bool p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
}
function log(bool p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
}
function log(address p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
}
function log(address p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
}
function log(address p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
}
function log(address p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
}
function log(uint p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
}
function log(uint p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
}
function log(uint p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
}
function log(uint p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
}
function log(uint p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
}
function log(uint p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
}
function log(uint p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
}
function log(uint p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
}
function log(uint p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
}
function log(uint p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
}
function log(uint p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
}
function log(uint p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
}
function log(uint p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
}
function log(uint p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
}
function log(uint p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
}
function log(uint p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
}
function log(string memory p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
}
function log(string memory p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
}
function log(string memory p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
}
function log(string memory p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
}
function log(string memory p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
}
function log(string memory p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
}
function log(string memory p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
}
function log(string memory p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
}
function log(string memory p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
}
function log(string memory p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
}
function log(string memory p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
}
function log(string memory p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
}
function log(string memory p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
}
function log(string memory p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
}
function log(string memory p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
}
function log(string memory p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
}
function log(bool p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
}
function log(bool p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
}
function log(bool p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
}
function log(bool p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
}
function log(bool p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
}
function log(bool p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
}
function log(bool p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
}
function log(bool p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
}
function log(bool p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
}
function log(bool p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
}
function log(bool p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
}
function log(bool p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
}
function log(bool p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
}
function log(bool p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
}
function log(bool p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
}
function log(bool p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
}
function log(address p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
}
function log(address p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
}
function log(address p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
}
function log(address p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
}
function log(address p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
}
function log(address p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
}
function log(address p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
}
function log(address p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
}
function log(address p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
}
function log(address p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
}
function log(address p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
}
function log(address p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
}
function log(address p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
}
function log(address p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
}
function log(address p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
}
function log(address p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
}
function log(uint p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.6.12;
library FixedPointMath {
uint256 public constant DECIMALS = 18;
uint256 public constant SCALAR = 10**DECIMALS;
struct FixedDecimal {
uint256 x;
}
function fromU256(uint256 value) internal pure returns (FixedDecimal memory) {
uint256 x;
require(value == 0 || (x = value * SCALAR) / SCALAR == value);
return FixedDecimal(x);
}
function maximumValue() internal pure returns (FixedDecimal memory) {
return FixedDecimal(uint256(-1));
}
function add(FixedDecimal memory self, FixedDecimal memory value) internal pure returns (FixedDecimal memory) {
uint256 x;
require((x = self.x + value.x) >= self.x);
return FixedDecimal(x);
}
function add(FixedDecimal memory self, uint256 value) internal pure returns (FixedDecimal memory) {
return add(self, fromU256(value));
}
function sub(FixedDecimal memory self, FixedDecimal memory value) internal pure returns (FixedDecimal memory) {
uint256 x;
require((x = self.x - value.x) <= self.x);
return FixedDecimal(x);
}
function sub(FixedDecimal memory self, uint256 value) internal pure returns (FixedDecimal memory) {
return sub(self, fromU256(value));
}
function mul(FixedDecimal memory self, uint256 value) internal pure returns (FixedDecimal memory) {
uint256 x;
require(value == 0 || (x = self.x * value) / value == self.x);
return FixedDecimal(x);
}
function div(FixedDecimal memory self, uint256 value) internal pure returns (FixedDecimal memory) {
require(value != 0);
return FixedDecimal(self.x / value);
}
function cmp(FixedDecimal memory self, FixedDecimal memory value) internal pure returns (int256) {
if (self.x < value.x) {
return -1;
}
if (self.x > value.x) {
return 1;
}
return 0;
}
function decode(FixedDecimal memory self) internal pure returns (uint256) {
return self.x / SCALAR;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IDetailedERC20 is IERC20 {
function name() external returns (string memory);
function symbol() external returns (string memory);
function decimals() external returns (uint8);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IDetailedERC20.sol";
/// Interface for all Vault Adapter implementations.
interface IVaultAdapter {
/// @dev Gets the token that the adapter accepts.
function token() external view returns (IDetailedERC20);
/// @dev The total value of the assets deposited into the vault.
function totalValue() external view returns (uint256);
/// @dev Deposits funds into the vault.
///
/// @param _amount the amount of funds to deposit.
function deposit(uint256 _amount) external;
/// @dev Attempts to withdraw funds from the wrapped vault.
///
/// The amount withdrawn to the recipient may be less than the amount requested.
///
/// @param _recipient the recipient of the funds.
/// @param _amount the amount of funds to withdraw.
function withdraw(address _recipient, uint256 _amount) external;
}
pragma solidity ^0.6.12;
interface IyVaultV2 {
function token() external view returns (address);
function deposit() external returns (uint);
function deposit(uint) external returns (uint);
function deposit(uint, address) external returns (uint);
function withdraw() external returns (uint);
function withdraw(uint) external returns (uint);
function withdraw(uint, address) external returns (uint);
function withdraw(uint, address, uint) external returns (uint);
function permit(address, address, uint, uint, bytes32) external view returns (bool);
function pricePerShare() external view returns (uint);
function apiVersion() external view returns (string memory);
function totalAssets() external view returns (uint);
function maxAvailableShares() external view returns (uint);
function debtOutstanding() external view returns (uint);
function debtOutstanding(address strategy) external view returns (uint);
function creditAvailable() external view returns (uint);
function creditAvailable(address strategy) external view returns (uint);
function availableDepositLimit() external view returns (uint);
function expectedReturn() external view returns (uint);
function expectedReturn(address strategy) external view returns (uint);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function totalSupply() external view returns (uint);
function governance() external view returns (address);
function management() external view returns (address);
function guardian() external view returns (address);
function guestList() external view returns (address);
function strategies(address) external view returns (uint, uint, uint, uint, uint, uint, uint, uint);
function withdrawalQueue(uint) external view returns (address);
function emergencyShutdown() external view returns (bool);
function depositLimit() external view returns (uint);
function debtRatio() external view returns (uint);
function totalDebt() external view returns (uint);
function lastReport() external view returns (uint);
function activation() external view returns (uint);
function rewards() external view returns (address);
function managementFee() external view returns (uint);
function performanceFee() external view returns (uint);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "../interfaces/IVaultAdapter.sol";
contract VaultAdapterMock is IVaultAdapter {
using SafeERC20 for IDetailedERC20;
IDetailedERC20 private _token;
constructor(IDetailedERC20 token_) public {
_token = token_;
}
function token() external view override returns (IDetailedERC20) {
return _token;
}
function totalValue() external view override returns (uint256) {
return _token.balanceOf(address(this));
}
function deposit(uint256 _amount) external override { }
function withdraw(address _recipient, uint256 _amount) external override {
_token.safeTransfer(_recipient, _amount);
}
}
pragma solidity 0.6.12;
import "@openzeppelin/contracts/GSN/Context.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./interfaces/IERC20Burnable.sol";
import "hardhat/console.sol";
// ___ __ __ _ ___ __ _
// / _ | / / ____ / / ___ __ _ (_) __ __ / _ \ ____ ___ ___ ___ ___ / /_ ___ (_)
// / __ | / / / __/ / _ \/ -_) / ' \ / / \ \ / / ___/ / __// -_) (_-</ -_) / _ \/ __/ (_-< _
// /_/ |_|/_/ \__/ /_//_/\__/ /_/_/_//_/ /_\_\ /_/ /_/ \__/ /___/\__/ /_//_/\__/ /___/(_)
//
// .___________..______ ___ .__ __. _______..___ ___. __ __ .___________. _______ .______
// | || _ \ / \ | \ | | / || \/ | | | | | | || ____|| _ \
// `---| |----`| |_) | / ^ \ | \| | | (----`| \ / | | | | | `---| |----`| |__ | |_) |
// | | | / / /_\ \ | . ` | \ \ | |\/| | | | | | | | | __| | /
// | | | |\ \----. / _____ \ | |\ | .----) | | | | | | `--' | | | | |____ | |\ \----.
// |__| | _| `._____|/__/ \__\ |__| \__| |_______/ |__| |__| \______/ |__| |_______|| _| `._____|
/**
* @dev Implementation of the {IERC20Burnable} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20Burnable-approve}.
*/
contract Transmuter is Context {
using SafeMath for uint256;
using SafeERC20 for IERC20Burnable;
using Address for address;
address public constant ZERO_ADDRESS = address(0);
uint256 public TRANSMUTATION_PERIOD;
address public AlToken;
address public Token;
mapping(address => uint256) public depositedAlTokens;
mapping(address => uint256) public tokensInBucket;
mapping(address => uint256) public realisedTokens;
mapping(address => uint256) public lastDividendPoints;
mapping(address => bool) public userIsKnown;
mapping(uint256 => address) public userList;
uint256 public nextUser;
uint256 public totalSupplyAltokens;
uint256 public buffer;
uint256 public lastDepositBlock;
///@dev values needed to calculate the distribution of base asset in proportion for alTokens staked
uint256 public pointMultiplier = 10e18;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
/// @dev alchemist addresses whitelisted
mapping (address => bool) public whiteList;
/// @dev The address of the account which currently has administrative capabilities over this contract.
address public governance;
/// @dev The address of the pending governance.
address public pendingGovernance;
event GovernanceUpdated(
address governance
);
event PendingGovernanceUpdated(
address pendingGovernance
);
event TransmuterPeriodUpdated(
uint256 newTransmutationPeriod
);
constructor(address _AlToken, address _Token, address _governance) public {
require(_governance != ZERO_ADDRESS, "Transmuter: 0 gov");
governance = _governance;
AlToken = _AlToken;
Token = _Token;
TRANSMUTATION_PERIOD = 50;
}
///@return displays the user's share of the pooled alTokens.
function dividendsOwing(address account) public view returns (uint256) {
uint256 newDividendPoints = totalDividendPoints.sub(lastDividendPoints[account]);
return depositedAlTokens[account].mul(newDividendPoints).div(pointMultiplier);
}
///@dev modifier to fill the bucket and keep bookkeeping correct incase of increase/decrease in shares
modifier updateAccount(address account) {
uint256 owing = dividendsOwing(account);
if (owing > 0) {
unclaimedDividends = unclaimedDividends.sub(owing);
tokensInBucket[account] = tokensInBucket[account].add(owing);
}
lastDividendPoints[account] = totalDividendPoints;
_;
}
///@dev modifier add users to userlist. Users are indexed in order to keep track of when a bond has been filled
modifier checkIfNewUser() {
if (!userIsKnown[msg.sender]) {
userList[nextUser] = msg.sender;
userIsKnown[msg.sender] = true;
nextUser++;
}
_;
}
///@dev run the phased distribution of the buffered funds
modifier runPhasedDistribution() {
uint256 _lastDepositBlock = lastDepositBlock;
uint256 _currentBlock = block.number;
uint256 _toDistribute = 0;
uint256 _buffer = buffer;
// check if there is something in bufffer
if (_buffer > 0) {
// NOTE: if last deposit was updated in the same block as the current call
// then the below logic gates will fail
//calculate diffrence in time
uint256 deltaTime = _currentBlock.sub(_lastDepositBlock);
// distribute all if bigger than timeframe
if(deltaTime >= TRANSMUTATION_PERIOD) {
_toDistribute = _buffer;
} else {
//needs to be bigger than 0 cuzz solidity no decimals
if(_buffer.mul(deltaTime) > TRANSMUTATION_PERIOD)
{
_toDistribute = _buffer.mul(deltaTime).div(TRANSMUTATION_PERIOD);
}
}
// factually allocate if any needs distribution
if(_toDistribute > 0){
// remove from buffer
buffer = _buffer.sub(_toDistribute);
// increase the allocation
increaseAllocations(_toDistribute);
}
}
// current timeframe is now the last
lastDepositBlock = _currentBlock;
_;
}
/// @dev A modifier which checks if whitelisted for minting.
modifier onlyWhitelisted() {
require(whiteList[msg.sender], "Transmuter: !whitelisted");
_;
}
/// @dev Checks that the current message sender or caller is the governance address.
///
///
modifier onlyGov() {
require(msg.sender == governance, "Transmuter: !governance");
_;
}
///@dev set the TRANSMUTATION_PERIOD variable
///
/// sets the length (in blocks) of one full distribution phase
function setTransmutationPeriod(uint256 newTransmutationPeriod) public onlyGov() {
TRANSMUTATION_PERIOD = newTransmutationPeriod;
emit TransmuterPeriodUpdated(TRANSMUTATION_PERIOD);
}
///@dev claims the base token after it has been transmuted
///
///This function reverts if there is no realisedToken balance
function claim() public {
address sender = msg.sender;
require(realisedTokens[sender] > 0);
uint256 value = realisedTokens[sender];
realisedTokens[sender] = 0;
IERC20Burnable(Token).safeTransfer(sender, value);
}
///@dev Withdraws staked alTokens from the transmuter
///
/// This function reverts if you try to draw more tokens than you deposited
///
///@param amount the amount of alTokens to unstake
function unstake(uint256 amount) public updateAccount(msg.sender) {
// by calling this function before transmuting you forfeit your gained allocation
address sender = msg.sender;
require(depositedAlTokens[sender] >= amount,"Transmuter: unstake amount exceeds deposited amount");
depositedAlTokens[sender] = depositedAlTokens[sender].sub(amount);
totalSupplyAltokens = totalSupplyAltokens.sub(amount);
IERC20Burnable(AlToken).safeTransfer(sender, amount);
}
///@dev Deposits alTokens into the transmuter
///
///@param amount the amount of alTokens to stake
function stake(uint256 amount)
public
runPhasedDistribution()
updateAccount(msg.sender)
checkIfNewUser()
{
// requires approval of AlToken first
address sender = msg.sender;
//require tokens transferred in;
IERC20Burnable(AlToken).safeTransferFrom(sender, address(this), amount);
totalSupplyAltokens = totalSupplyAltokens.add(amount);
depositedAlTokens[sender] = depositedAlTokens[sender].add(amount);
}
/// @dev Converts the staked alTokens to the base tokens in amount of the sum of pendingdivs and tokensInBucket
///
/// once the alToken has been converted, it is burned, and the base token becomes realisedTokens which can be recieved using claim()
///
/// reverts if there are no pendingdivs or tokensInBucket
function transmute() public runPhasedDistribution() updateAccount(msg.sender) {
address sender = msg.sender;
uint256 pendingz = tokensInBucket[sender];
uint256 diff;
require(pendingz > 0, "need to have pending in bucket");
tokensInBucket[sender] = 0;
// check bucket overflow
if (pendingz > depositedAlTokens[sender]) {
diff = pendingz.sub(depositedAlTokens[sender]);
// remove overflow
pendingz = depositedAlTokens[sender];
}
// decrease altokens
depositedAlTokens[sender] = depositedAlTokens[sender].sub(pendingz);
// BURN ALTOKENS
IERC20Burnable(AlToken).burn(pendingz);
// adjust total
totalSupplyAltokens = totalSupplyAltokens.sub(pendingz);
// reallocate overflow
increaseAllocations(diff);
// add payout
realisedTokens[sender] = realisedTokens[sender].add(pendingz);
}
/// @dev Executes transmute() on another account that has had more base tokens allocated to it than alTokens staked.
///
/// The caller of this function will have the surlus base tokens credited to their tokensInBucket balance, rewarding them for performing this action
///
/// This function reverts if the address to transmute is not over-filled.
///
/// @param toTransmute address of the account you will force transmute.
function forceTransmute(address toTransmute)
public
runPhasedDistribution()
updateAccount(msg.sender)
updateAccount(toTransmute)
{
//load into memory
address sender = msg.sender;
uint256 pendingz = tokensInBucket[toTransmute];
// check restrictions
require(
pendingz > depositedAlTokens[toTransmute],
"Transmuter: !overflow"
);
// empty bucket
tokensInBucket[toTransmute] = 0;
// calculaate diffrence
uint256 diff = pendingz.sub(depositedAlTokens[toTransmute]);
// remove overflow
pendingz = depositedAlTokens[toTransmute];
// decrease altokens
depositedAlTokens[toTransmute] = 0;
// BURN ALTOKENS
IERC20Burnable(AlToken).burn(pendingz);
// adjust total
totalSupplyAltokens = totalSupplyAltokens.sub(pendingz);
// reallocate overflow
tokensInBucket[sender] = tokensInBucket[sender].add(diff);
// add payout
realisedTokens[toTransmute] = realisedTokens[toTransmute].add(pendingz);
// force payout of realised tokens of the toTransmute address
if (realisedTokens[toTransmute] > 0) {
uint256 value = realisedTokens[toTransmute];
realisedTokens[toTransmute] = 0;
IERC20Burnable(Token).safeTransfer(toTransmute, value);
}
}
/// @dev Transmutes and unstakes all alTokens
///
/// This function combines the transmute and unstake functions for ease of use
function exit() public {
transmute();
uint256 toWithdraw = depositedAlTokens[msg.sender];
unstake(toWithdraw);
}
/// @dev Transmutes and claims all converted base tokens.
///
/// This function combines the transmute and claim functions while leaving your remaining alTokens staked.
function transmuteAndClaim() public {
transmute();
claim();
}
/// @dev Transmutes, claims base tokens, and withdraws alTokens.
///
/// This function helps users to exit the transmuter contract completely after converting their alTokens to the base pair.
function transmuteClaimAndWithdraw() public {
transmute();
claim();
uint256 toWithdraw = depositedAlTokens[msg.sender];
unstake(toWithdraw);
}
/// @dev Distributes the base token proportionally to all alToken stakers.
///
/// This function is meant to be called by the Alchemist contract for when it is sending yield to the transmuter.
/// Anyone can call this and add funds, idk why they would do that though...
///
/// @param origin the account that is sending the tokens to be distributed.
/// @param amount the amount of base tokens to be distributed to the transmuter.
function distribute(address origin, uint256 amount) public onlyWhitelisted() runPhasedDistribution() {
IERC20Burnable(Token).safeTransferFrom(origin, address(this), amount);
buffer = buffer.add(amount);
}
/// @dev Allocates the incoming yield proportionally to all alToken stakers.
///
/// @param amount the amount of base tokens to be distributed in the transmuter.
function increaseAllocations(uint256 amount) internal {
if(totalSupplyAltokens > 0 && amount > 0) {
totalDividendPoints = totalDividendPoints.add(
amount.mul(pointMultiplier).div(totalSupplyAltokens)
);
unclaimedDividends = unclaimedDividends.add(amount);
} else {
buffer = buffer.add(amount);
}
}
/// @dev Gets the status of a user's staking position.
///
/// The total amount allocated to a user is the sum of pendingdivs and inbucket.
///
/// @param user the address of the user you wish to query.
///
/// returns user status
function userInfo(address user)
public
view
returns (
uint256 depositedAl,
uint256 pendingdivs,
uint256 inbucket,
uint256 realised
)
{
uint256 _depositedAl = depositedAlTokens[user];
uint256 _toDistribute = buffer.mul(block.number.sub(lastDepositBlock)).div(TRANSMUTATION_PERIOD);
if(block.number.sub(lastDepositBlock) > TRANSMUTATION_PERIOD){
_toDistribute = buffer;
}
uint256 _pendingdivs = _toDistribute.mul(depositedAlTokens[user]).div(totalSupplyAltokens);
uint256 _inbucket = tokensInBucket[user].add(dividendsOwing(user));
uint256 _realised = realisedTokens[user];
return (_depositedAl, _pendingdivs, _inbucket, _realised);
}
/// @dev Gets the status of multiple users in one call
///
/// This function is used to query the contract to check for
/// accounts that have overfilled positions in order to check
/// who can be force transmuted.
///
/// @param from the first index of the userList
/// @param to the last index of the userList
///
/// returns the userList with their staking status in paginated form.
function getMultipleUserInfo(uint256 from, uint256 to)
public
view
returns (address[] memory theUserList, uint256[] memory theUserData)
{
uint256 i = from;
uint256 delta = to - from;
address[] memory _theUserList = new address[](delta); //user
uint256[] memory _theUserData = new uint256[](delta * 2); //deposited-bucket
uint256 y = 0;
uint256 _toDistribute = buffer.mul(block.number.sub(lastDepositBlock)).div(TRANSMUTATION_PERIOD);
if(block.number.sub(lastDepositBlock) > TRANSMUTATION_PERIOD){
_toDistribute = buffer;
}
for (uint256 x = 0; x < delta; x += 1) {
_theUserList[x] = userList[i];
_theUserData[y] = depositedAlTokens[userList[i]];
_theUserData[y + 1] = dividendsOwing(userList[i]).add(tokensInBucket[userList[i]]).add(_toDistribute.mul(depositedAlTokens[userList[i]]).div(totalSupplyAltokens));
y += 2;
i += 1;
}
return (_theUserList, _theUserData);
}
/// @dev Gets info on the buffer
///
/// This function is used to query the contract to get the
/// latest state of the buffer
///
/// @return _toDistribute the amount ready to be distributed
/// @return _deltaBlocks the amount of time since the last phased distribution
/// @return _buffer the amount in the buffer
function bufferInfo() public view returns (uint256 _toDistribute, uint256 _deltaBlocks, uint256 _buffer){
_deltaBlocks = block.number.sub(lastDepositBlock);
_buffer = buffer;
_toDistribute = _buffer.mul(_deltaBlocks).div(TRANSMUTATION_PERIOD);
}
/// @dev Sets the pending governance.
///
/// This function reverts if the new pending governance is the zero address or the caller is not the current
/// governance. This is to prevent the contract governance being set to the zero address which would deadlock
/// privileged contract functionality.
///
/// @param _pendingGovernance the new pending governance.
function setPendingGovernance(address _pendingGovernance) external onlyGov {
require(_pendingGovernance != ZERO_ADDRESS, "Transmuter: 0 gov");
pendingGovernance = _pendingGovernance;
emit PendingGovernanceUpdated(_pendingGovernance);
}
/// @dev Accepts the role as governance.
///
/// This function reverts if the caller is not the new pending governance.
function acceptGovernance() external {
require(msg.sender == pendingGovernance,"!pendingGovernance");
address _pendingGovernance = pendingGovernance;
governance = _pendingGovernance;
emit GovernanceUpdated(_pendingGovernance);
}
/// This function reverts if the caller is not governance
///
/// @param _toWhitelist the account to mint tokens to.
/// @param _state the whitelist state.
function setWhitelist(address _toWhitelist, bool _state) external onlyGov {
whiteList[_toWhitelist] = _state;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.8;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IERC20Burnable is IERC20 {
function burn(uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
//import "hardhat/console.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {FixedPointMath} from "./libraries/FixedPointMath.sol";
import {IMintableERC20} from "./interfaces/IMintableERC20.sol";
import {Pool} from "./libraries/pools/Pool.sol";
import {Stake} from "./libraries/pools/Stake.sol";
import {StakingPools} from "./StakingPools.sol";
import "hardhat/console.sol";
/// @title StakingPools
// ___ __ __ _ ___ __ _
// / _ | / / ____ / / ___ __ _ (_) __ __ / _ \ ____ ___ ___ ___ ___ / /_ ___ (_)
// / __ | / / / __/ / _ \/ -_) / ' \ / / \ \ / / ___/ / __// -_) (_-</ -_) / _ \/ __/ (_-< _
// /_/ |_|/_/ \__/ /_//_/\__/ /_/_/_//_/ /_\_\ /_/ /_/ \__/ /___/\__/ /_//_/\__/ /___/(_)
//
// _______..___________. ___ __ ___ __ .__ __. _______ .______ ______ ______ __ _______.
// / || | / \ | |/ / | | | \ | | / _____| | _ \ / __ \ / __ \ | | / |
// | (----``---| |----` / ^ \ | ' / | | | \| | | | __ | |_) | | | | | | | | | | | | (----`
// \ \ | | / /_\ \ | < | | | . ` | | | |_ | | ___/ | | | | | | | | | | \ \
// .----) | | | / _____ \ | . \ | | | |\ | | |__| | | | | `--' | | `--' | | `----..----) |
// |_______/ |__| /__/ \__\ |__|\__\ |__| |__| \__| \______| | _| \______/ \______/ |_______||_______/
///
/// @dev A contract which allows users to stake to farm tokens.
///
/// This contract was inspired by Chef Nomi's 'MasterChef' contract which can be found in this
/// repository: https://github.com/sushiswap/sushiswap.
contract StakingPools is ReentrancyGuard {
using FixedPointMath for FixedPointMath.FixedDecimal;
using Pool for Pool.Data;
using Pool for Pool.List;
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Stake for Stake.Data;
event PendingGovernanceUpdated(
address pendingGovernance
);
event GovernanceUpdated(
address governance
);
event RewardRateUpdated(
uint256 rewardRate
);
event PoolRewardWeightUpdated(
uint256 indexed poolId,
uint256 rewardWeight
);
event PoolCreated(
uint256 indexed poolId,
IERC20 indexed token
);
event TokensDeposited(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
event TokensWithdrawn(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
event TokensClaimed(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
/// @dev The token which will be minted as a reward for staking.
IMintableERC20 public reward;
/// @dev The address of the account which currently has administrative capabilities over this contract.
address public governance;
address public pendingGovernance;
/// @dev Tokens are mapped to their pool identifier plus one. Tokens that do not have an associated pool
/// will return an identifier of zero.
mapping(IERC20 => uint256) public tokenPoolIds;
/// @dev The context shared between the pools.
Pool.Context private _ctx;
/// @dev A list of all of the pools.
Pool.List private _pools;
/// @dev A mapping of all of the user stakes mapped first by pool and then by address.
mapping(address => mapping(uint256 => Stake.Data)) private _stakes;
constructor(
IMintableERC20 _reward,
address _governance
) public {
require(_governance != address(0), "StakingPools: governance address cannot be 0x0");
reward = _reward;
governance = _governance;
}
/// @dev A modifier which reverts when the caller is not the governance.
modifier onlyGovernance() {
require(msg.sender == governance, "StakingPools: only governance");
_;
}
/// @dev Sets the governance.
///
/// This function can only called by the current governance.
///
/// @param _pendingGovernance the new pending governance.
function setPendingGovernance(address _pendingGovernance) external onlyGovernance {
require(_pendingGovernance != address(0), "StakingPools: pending governance address cannot be 0x0");
pendingGovernance = _pendingGovernance;
emit PendingGovernanceUpdated(_pendingGovernance);
}
function acceptGovernance() external {
require(msg.sender == pendingGovernance, "StakingPools: only pending governance");
address _pendingGovernance = pendingGovernance;
governance = _pendingGovernance;
emit GovernanceUpdated(_pendingGovernance);
}
/// @dev Sets the distribution reward rate.
///
/// This will update all of the pools.
///
/// @param _rewardRate The number of tokens to distribute per second.
function setRewardRate(uint256 _rewardRate) external onlyGovernance {
_updatePools();
_ctx.rewardRate = _rewardRate;
emit RewardRateUpdated(_rewardRate);
}
/// @dev Creates a new pool.
///
/// The created pool will need to have its reward weight initialized before it begins generating rewards.
///
/// @param _token The token the pool will accept for staking.
///
/// @return the identifier for the newly created pool.
function createPool(IERC20 _token) external onlyGovernance returns (uint256) {
require(tokenPoolIds[_token] == 0, "StakingPools: token already has a pool");
uint256 _poolId = _pools.length();
_pools.push(Pool.Data({
token: _token,
totalDeposited: 0,
rewardWeight: 0,
accumulatedRewardWeight: FixedPointMath.FixedDecimal(0),
lastUpdatedBlock: block.number
}));
tokenPoolIds[_token] = _poolId + 1;
emit PoolCreated(_poolId, _token);
return _poolId;
}
/// @dev Sets the reward weights of all of the pools.
///
/// @param _rewardWeights The reward weights of all of the pools.
function setRewardWeights(uint256[] calldata _rewardWeights) external onlyGovernance {
require(_rewardWeights.length == _pools.length(), "StakingPools: weights length mismatch");
_updatePools();
uint256 _totalRewardWeight = _ctx.totalRewardWeight;
for (uint256 _poolId = 0; _poolId < _pools.length(); _poolId++) {
Pool.Data storage _pool = _pools.get(_poolId);
uint256 _currentRewardWeight = _pool.rewardWeight;
if (_currentRewardWeight == _rewardWeights[_poolId]) {
continue;
}
// FIXME
_totalRewardWeight = _totalRewardWeight.sub(_currentRewardWeight).add(_rewardWeights[_poolId]);
_pool.rewardWeight = _rewardWeights[_poolId];
emit PoolRewardWeightUpdated(_poolId, _rewardWeights[_poolId]);
}
_ctx.totalRewardWeight = _totalRewardWeight;
}
/// @dev Stakes tokens into a pool.
///
/// @param _poolId the pool to deposit tokens into.
/// @param _depositAmount the amount of tokens to deposit.
function deposit(uint256 _poolId, uint256 _depositAmount) external nonReentrant {
Pool.Data storage _pool = _pools.get(_poolId);
_pool.update(_ctx);
Stake.Data storage _stake = _stakes[msg.sender][_poolId];
_stake.update(_pool, _ctx);
_deposit(_poolId, _depositAmount);
}
/// @dev Withdraws staked tokens from a pool.
///
/// @param _poolId The pool to withdraw staked tokens from.
/// @param _withdrawAmount The number of tokens to withdraw.
function withdraw(uint256 _poolId, uint256 _withdrawAmount) 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, _withdrawAmount);
}
/// @dev Claims all rewarded tokens from a pool.
///
/// @param _poolId The pool to claim rewards from.
///
/// @notice use this function to claim the tokens from a corresponding pool by ID.
function claim(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);
}
/// @dev Claims all rewards from a pool and then withdraws all staked tokens.
///
/// @param _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);
}
/// @dev Gets the rate at which tokens are minted to stakers for all pools.
///
/// @return the reward rate.
function rewardRate() external view returns (uint256) {
return _ctx.rewardRate;
}
/// @dev Gets the total reward weight between all the pools.
///
/// @return the total reward weight.
function totalRewardWeight() external view returns (uint256) {
return _ctx.totalRewardWeight;
}
/// @dev Gets the number of pools that exist.
///
/// @return the pool count.
function poolCount() external view returns (uint256) {
return _pools.length();
}
/// @dev Gets the token a pool accepts.
///
/// @param _poolId the identifier of the pool.
///
/// @return the token.
function getPoolToken(uint256 _poolId) external view returns (IERC20) {
Pool.Data storage _pool = _pools.get(_poolId);
return _pool.token;
}
/// @dev Gets the total amount of funds staked in a pool.
///
/// @param _poolId the identifier of the pool.
///
/// @return the total amount of staked or deposited tokens.
function getPoolTotalDeposited(uint256 _poolId) external view returns (uint256) {
Pool.Data storage _pool = _pools.get(_poolId);
return _pool.totalDeposited;
}
/// @dev Gets the reward weight of a pool which determines how much of the total rewards it receives per block.
///
/// @param _poolId the identifier of the pool.
///
/// @return the pool reward weight.
function getPoolRewardWeight(uint256 _poolId) external view returns (uint256) {
Pool.Data storage _pool = _pools.get(_poolId);
return _pool.rewardWeight;
}
/// @dev Gets the amount of tokens per block being distributed to stakers for a pool.
///
/// @param _poolId the identifier of the pool.
///
/// @return the pool reward rate.
function getPoolRewardRate(uint256 _poolId) external view returns (uint256) {
Pool.Data storage _pool = _pools.get(_poolId);
return _pool.getRewardRate(_ctx);
}
/// @dev Gets the number of tokens a user has staked into a pool.
///
/// @param _account The account to query.
/// @param _poolId the identifier of the pool.
///
/// @return the amount of deposited tokens.
function getStakeTotalDeposited(address _account, uint256 _poolId) external view returns (uint256) {
Stake.Data storage _stake = _stakes[_account][_poolId];
return _stake.totalDeposited;
}
/// @dev Gets the number of unclaimed reward tokens a user can claim from a pool.
///
/// @param _account The account to get the unclaimed balance of.
/// @param _poolId The pool to check for unclaimed rewards.
///
/// @return the amount of unclaimed reward tokens a user has in a pool.
function getStakeTotalUnclaimed(address _account, uint256 _poolId) external view returns (uint256) {
Stake.Data storage _stake = _stakes[_account][_poolId];
return _stake.getUpdatedTotalUnclaimed(_pools.get(_poolId), _ctx);
}
/// @dev Updates all of the pools.
function _updatePools() internal {
for (uint256 _poolId = 0; _poolId < _pools.length(); _poolId++) {
Pool.Data storage _pool = _pools.get(_poolId);
_pool.update(_ctx);
}
}
/// @dev Stakes tokens into a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId the pool to deposit tokens into.
/// @param _depositAmount the amount of tokens to deposit.
function _deposit(uint256 _poolId, uint256 _depositAmount) internal {
Pool.Data storage _pool = _pools.get(_poolId);
Stake.Data storage _stake = _stakes[msg.sender][_poolId];
_pool.totalDeposited = _pool.totalDeposited.add(_depositAmount);
_stake.totalDeposited = _stake.totalDeposited.add(_depositAmount);
_pool.token.safeTransferFrom(msg.sender, address(this), _depositAmount);
emit TokensDeposited(msg.sender, _poolId, _depositAmount);
}
/// @dev Withdraws staked tokens from a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId The pool to withdraw staked tokens from.
/// @param _withdrawAmount The number of tokens to withdraw.
function _withdraw(uint256 _poolId, uint256 _withdrawAmount) internal {
Pool.Data storage _pool = _pools.get(_poolId);
Stake.Data storage _stake = _stakes[msg.sender][_poolId];
_pool.totalDeposited = _pool.totalDeposited.sub(_withdrawAmount);
_stake.totalDeposited = _stake.totalDeposited.sub(_withdrawAmount);
_pool.token.safeTransfer(msg.sender, _withdrawAmount);
emit TokensWithdrawn(msg.sender, _poolId, _withdrawAmount);
}
/// @dev Claims all rewarded tokens from a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId The pool to claim rewards from.
///
/// @notice use this function to claim the tokens from a corresponding pool by ID.
function _claim(uint256 _poolId) internal {
Stake.Data storage _stake = _stakes[msg.sender][_poolId];
uint256 _claimAmount = _stake.totalUnclaimed;
_stake.totalUnclaimed = 0;
reward.mint(msg.sender, _claimAmount);
emit TokensClaimed(msg.sender, _poolId, _claimAmount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "../GSN/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import {IDetailedERC20} from "./IDetailedERC20.sol";
interface IMintableERC20 is IDetailedERC20{
function mint(address _recipient, uint256 _amount) external;
function burnFrom(address account, uint256 amount) external;
function lowerHasMinted(uint256 amount)external;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {Math} from "@openzeppelin/contracts/math/Math.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {FixedPointMath} from "../FixedPointMath.sol";
import {IDetailedERC20} from "../../interfaces/IDetailedERC20.sol";
import "hardhat/console.sol";
/// @title Pool
///
/// @dev A library which provides the Pool data struct and associated functions.
library Pool {
using FixedPointMath for FixedPointMath.FixedDecimal;
using Pool for Pool.Data;
using Pool for Pool.List;
using SafeMath for uint256;
struct Context {
uint256 rewardRate;
uint256 totalRewardWeight;
}
struct Data {
IERC20 token;
uint256 totalDeposited;
uint256 rewardWeight;
FixedPointMath.FixedDecimal accumulatedRewardWeight;
uint256 lastUpdatedBlock;
}
struct List {
Data[] elements;
}
/// @dev Updates the pool.
///
/// @param _ctx the pool context.
function update(Data storage _data, Context storage _ctx) internal {
_data.accumulatedRewardWeight = _data.getUpdatedAccumulatedRewardWeight(_ctx);
_data.lastUpdatedBlock = block.number;
}
/// @dev Gets the rate at which the pool will distribute rewards to stakers.
///
/// @param _ctx the pool context.
///
/// @return the reward rate of the pool in tokens per block.
function getRewardRate(Data storage _data, Context storage _ctx)
internal view
returns (uint256)
{
// console.log("get reward rate");
// console.log(uint(_data.rewardWeight));
// console.log(uint(_ctx.totalRewardWeight));
// console.log(uint(_ctx.rewardRate));
return _ctx.rewardRate.mul(_data.rewardWeight).div(_ctx.totalRewardWeight);
}
/// @dev Gets the accumulated reward weight of a pool.
///
/// @param _ctx the pool context.
///
/// @return the accumulated reward weight.
function getUpdatedAccumulatedRewardWeight(Data storage _data, Context storage _ctx)
internal view
returns (FixedPointMath.FixedDecimal memory)
{
if (_data.totalDeposited == 0) {
return _data.accumulatedRewardWeight;
}
uint256 _elapsedTime = block.number.sub(_data.lastUpdatedBlock);
if (_elapsedTime == 0) {
return _data.accumulatedRewardWeight;
}
uint256 _rewardRate = _data.getRewardRate(_ctx);
uint256 _distributeAmount = _rewardRate.mul(_elapsedTime);
if (_distributeAmount == 0) {
return _data.accumulatedRewardWeight;
}
FixedPointMath.FixedDecimal memory _rewardWeight = FixedPointMath.fromU256(_distributeAmount).div(_data.totalDeposited);
return _data.accumulatedRewardWeight.add(_rewardWeight);
}
/// @dev Adds an element to the list.
///
/// @param _element the element to add.
function push(List storage _self, Data memory _element) internal {
_self.elements.push(_element);
}
/// @dev Gets an element from the list.
///
/// @param _index the index in the list.
///
/// @return the element at the specified index.
function get(List storage _self, uint256 _index) internal view returns (Data storage) {
return _self.elements[_index];
}
/// @dev Gets the last element in the list.
///
/// This function will revert if there are no elements in the list.
///ck
/// @return the last element in the list.
function last(List storage _self) internal view returns (Data storage) {
return _self.elements[_self.lastIndex()];
}
/// @dev Gets the index of the last element in the list.
///
/// This function will revert if there are no elements in the list.
///
/// @return the index of the last element.
function lastIndex(List storage _self) internal view returns (uint256) {
uint256 _length = _self.length();
return _length.sub(1, "Pool.List: list is empty");
}
/// @dev Gets the number of elements in the list.
///
/// @return the number of elements.
function length(List storage _self) internal view returns (uint256) {
return _self.elements.length;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {Math} from "@openzeppelin/contracts/math/Math.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {FixedPointMath} from "../FixedPointMath.sol";
import {IDetailedERC20} from "../../interfaces/IDetailedERC20.sol";
import {Pool} from "./Pool.sol";
import "hardhat/console.sol";
/// @title Stake
///
/// @dev A library which provides the Stake data struct and associated functions.
library Stake {
using FixedPointMath for FixedPointMath.FixedDecimal;
using Pool for Pool.Data;
using SafeMath for uint256;
using Stake for Stake.Data;
struct Data {
uint256 totalDeposited;
uint256 totalUnclaimed;
FixedPointMath.FixedDecimal lastAccumulatedWeight;
}
function update(Data storage _self, Pool.Data storage _pool, Pool.Context storage _ctx) internal {
_self.totalUnclaimed = _self.getUpdatedTotalUnclaimed(_pool, _ctx);
_self.lastAccumulatedWeight = _pool.getUpdatedAccumulatedRewardWeight(_ctx);
}
function getUpdatedTotalUnclaimed(Data storage _self, Pool.Data storage _pool, Pool.Context storage _ctx)
internal view
returns (uint256)
{
FixedPointMath.FixedDecimal memory _currentAccumulatedWeight = _pool.getUpdatedAccumulatedRewardWeight(_ctx);
FixedPointMath.FixedDecimal memory _lastAccumulatedWeight = _self.lastAccumulatedWeight;
if (_currentAccumulatedWeight.cmp(_lastAccumulatedWeight) == 0) {
return _self.totalUnclaimed;
}
uint256 _distributedAmount = _currentAccumulatedWeight
.sub(_lastAccumulatedWeight)
.mul(_self.totalDeposited)
.decode();
return _self.totalUnclaimed.add(_distributedAmount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IDetailedERC20} from "./interfaces/IDetailedERC20.sol";
/// @title TimeToken
///
/// @dev This is the contract for the Alchemix time token.
///
contract TimeToken is AccessControl, ERC20("Technological Instantiation Meta Env", "TIME") {
/// @dev The identifier of the role which maintains other roles.
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN");
/// @dev The identifier of the role which allows accounts to mint tokens.
bytes32 public constant MINTER_ROLE = keccak256("MINTER");
constructor() public {
_setupRole(ADMIN_ROLE, msg.sender);
_setupRole(MINTER_ROLE, msg.sender);
_setRoleAdmin(MINTER_ROLE, ADMIN_ROLE);
_setRoleAdmin(ADMIN_ROLE, ADMIN_ROLE);
}
/// @dev A modifier which checks that the caller has the minter role.
modifier onlyMinter() {
require(hasRole(MINTER_ROLE, msg.sender), "TimeToken: only minter");
_;
}
/// @dev Mints tokens to a recipient.
///
/// This function reverts if the caller does not have the minter role.
///
/// @param _recipient the account to mint tokens to.
/// @param _amount the amount of tokens to mint.
function mint(address _recipient, uint256 _amount) external onlyMinter {
_mint(_recipient, _amount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "../utils/EnumerableSet.sol";
import "../utils/Address.sol";
import "../GSN/Context.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "../../GSN/Context.sol";
import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IDetailedERC20} from "./interfaces/IDetailedERC20.sol";
/// @title AlToken
///
/// @dev This is the contract for the Alchemix utillity token usd.
///
/// Initially, the contract deployer is given both the admin and minter role. This allows them to pre-mine tokens,
/// transfer admin to a timelock contract, and lastly, grant the staking pools the minter role. After this is done,
/// the deployer must revoke their admin role and minter role.
contract AlToken is AccessControl, ERC20("Alchemix USD", "alUSD") {
using SafeERC20 for ERC20;
/// @dev The identifier of the role which maintains other roles.
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN");
/// @dev The identifier of the role which allows accounts to mint tokens.
bytes32 public constant SENTINEL_ROLE = keccak256("SENTINEL");
/// @dev addresses whitelisted for minting new tokens
mapping (address => bool) public whiteList;
/// @dev addresses blacklisted for minting new tokens
mapping (address => bool) public blacklist;
/// @dev addresses paused for minting new tokens
mapping (address => bool) public paused;
/// @dev ceiling per address for minting new tokens
mapping (address => uint256) public ceiling;
/// @dev already minted amount per address to track the ceiling
mapping (address => uint256) public hasMinted;
event Paused(address alchemistAddress, bool isPaused);
constructor() public {
_setupRole(ADMIN_ROLE, msg.sender);
_setupRole(SENTINEL_ROLE, msg.sender);
_setRoleAdmin(SENTINEL_ROLE,ADMIN_ROLE);
_setRoleAdmin(ADMIN_ROLE,ADMIN_ROLE);
}
/// @dev A modifier which checks if whitelisted for minting.
modifier onlyWhitelisted() {
require(whiteList[msg.sender], "AlUSD: Alchemist is not whitelisted");
_;
}
/// @dev Mints tokens to a recipient.
///
/// This function reverts if the caller does not have the minter role.
///
/// @param _recipient the account to mint tokens to.
/// @param _amount the amount of tokens to mint.
function mint(address _recipient, uint256 _amount) external onlyWhitelisted {
require(!blacklist[msg.sender], "AlUSD: Alchemist is blacklisted.");
uint256 _total = _amount.add(hasMinted[msg.sender]);
require(_total <= ceiling[msg.sender],"AlUSD: Alchemist's ceiling was breached.");
require(!paused[msg.sender], "AlUSD: user is currently paused.");
hasMinted[msg.sender] = hasMinted[msg.sender].add(_amount);
_mint(_recipient, _amount);
}
/// This function reverts if the caller does not have the admin role.
///
/// @param _toWhitelist the account to mint tokens to.
/// @param _state the whitelist state.
function setWhitelist(address _toWhitelist, bool _state) external onlyAdmin {
whiteList[_toWhitelist] = _state;
}
/// This function reverts if the caller does not have the admin role.
///
/// @param _newSentinel the account to set as sentinel.
function setSentinel(address _newSentinel) external onlyAdmin {
_setupRole(SENTINEL_ROLE, _newSentinel);
}
/// This function reverts if the caller does not have the admin role.
///
/// @param _toBlacklist the account to mint tokens to.
function setBlacklist(address _toBlacklist) external onlySentinel {
blacklist[_toBlacklist] = true;
}
/// This function reverts if the caller does not have the admin role.
function pauseAlchemist(address _toPause, bool _state) external onlySentinel {
paused[_toPause] = _state;
Paused(_toPause, _state);
}
/// This function reverts if the caller does not have the admin role.
///
/// @param _toSetCeiling the account set the ceiling off.
/// @param _ceiling the max amount of tokens the account is allowed to mint.
function setCeiling(address _toSetCeiling, uint256 _ceiling) external onlyAdmin {
ceiling[_toSetCeiling] = _ceiling;
}
/// @dev A modifier which checks that the caller has the admin role.
modifier onlyAdmin() {
require(hasRole(ADMIN_ROLE, msg.sender), "only admin");
_;
}
/// @dev A modifier which checks that the caller has the sentinel role.
modifier onlySentinel() {
require(hasRole(SENTINEL_ROLE, msg.sender), "only sentinel");
_;
}
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
/**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
/**
* @dev lowers hasminted from the caller's allocation
*
*/
function lowerHasMinted( uint256 amount) public onlyWhitelisted {
hasMinted[msg.sender] = hasMinted[msg.sender].sub(amount);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import "hardhat/console.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "../interfaces/IYearnController.sol";
import "../interfaces/IYearnVault.sol";
contract YearnVaultMock is ERC20 {
using SafeERC20 for IDetailedERC20;
using SafeMath for uint256;
uint256 public min = 9500;
uint256 public constant max = 10000;
IYearnController public controller;
IDetailedERC20 public token;
constructor(IDetailedERC20 _token, IYearnController _controller) public ERC20("yEarn Mock", "yMOCK") {
token = _token;
controller = _controller;
}
function vdecimals() external view returns (uint8) {
return decimals();
}
function balance() public view returns (uint256) {
return token.balanceOf(address(this)).add(controller.balanceOf(address(token)));
}
function available() public view returns (uint256) {
return token.balanceOf(address(this)).mul(min).div(max);
}
function earn() external {
uint _bal = available();
token.safeTransfer(address(controller), _bal);
controller.earn(address(token), _bal);
}
function deposit(uint256 _amount) external returns (uint){
uint _pool = balance();
uint _before = token.balanceOf(address(this));
token.safeTransferFrom(msg.sender, address(this), _amount);
uint _after = token.balanceOf(address(this));
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint _shares = 0;
if (totalSupply() == 0) {
_shares = _amount;
} else {
_shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, _shares);
}
function withdraw(uint _shares, address _recipient) external returns (uint) {
uint _r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
// Check balance
uint _b = token.balanceOf(address(this));
if (_b < _r) {
uint _withdraw = _r.sub(_b);
controller.withdraw(address(token), _withdraw);
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(_b);
if (_diff < _withdraw) {
_r = _b.add(_diff);
}
}
token.safeTransfer(_recipient, _r);
}
function pricePerShare() external view returns (uint256) {
return balance().mul(1e18).div(totalSupply());
}// changed to v2
/// @dev This is not part of the vault contract and is meant for quick debugging contracts to have control over
/// completely clearing the vault buffer to test certain behaviors better.
function clear() external {
token.safeTransfer(address(controller), token.balanceOf(address(this)));
controller.earn(address(token), token.balanceOf(address(this)));
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
interface IYearnController {
function balanceOf(address _token) external view returns (uint256);
function earn(address _token, uint256 _amount) external;
function withdraw(address _token, uint256 _withdrawAmount) external;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IDetailedERC20} from "./IDetailedERC20.sol";
interface IYearnVault {
function balanceOf(address user) external view returns (uint);
function pricePerShare() external view returns (uint);
function deposit(uint amount) external returns (uint);
function withdraw(uint shares, address recipient) external returns (uint);
function token() external view returns (IDetailedERC20);
function totalAssets() external view returns (uint);
function decimals() external view returns (uint8);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import "hardhat/console.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import "../interfaces/IYearnController.sol";
contract YearnControllerMock is IYearnController {
using SafeERC20 for IERC20;
using SafeMath for uint256;
address constant public blackhole = 0x000000000000000000000000000000000000dEaD;
uint256 public withdrawalFee = 50;
uint256 constant public withdrawalMax = 10000;
function setWithdrawalFee(uint256 _withdrawalFee) external {
withdrawalFee = _withdrawalFee;
}
function balanceOf(address _token) external view override returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
function earn(address _token, uint256 _amount) external override { }
function withdraw(address _token, uint256 _amount) external override {
uint _balance = IERC20(_token).balanceOf(address(this));
// uint _fee = _amount.mul(withdrawalFee).div(withdrawalMax);
// IERC20(_token).safeTransfer(blackhole, _fee);
IERC20(_token).safeTransfer(msg.sender, _amount);
}
}
/*
Copyright 2019 ZeroEx Intl.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./MultiSigWallet.sol";
/// @title Multisignature wallet with time lock- Allows multiple parties to execute a transaction after a time lock has passed.
/// @author Amir Bandeali - <[email protected]>
// solhint-disable not-rely-on-time
contract MultiSigWalletWithTimeLock is
MultiSigWallet
{
using SafeMath for uint256;
event ConfirmationTimeSet(uint256 indexed transactionId, uint256 confirmationTime);
event TimeLockChange(uint256 secondsTimeLocked);
uint256 public secondsTimeLocked;
mapping (uint256 => uint256) public confirmationTimes;
modifier fullyConfirmed(uint256 transactionId) {
require(
isConfirmed(transactionId),
"TX_NOT_FULLY_CONFIRMED"
);
_;
}
modifier pastTimeLock(uint256 transactionId) {
require(
block.timestamp >= confirmationTimes[transactionId].add(secondsTimeLocked),
"TIME_LOCK_INCOMPLETE"
);
_;
}
/// @dev Contract constructor sets initial owners, required number of confirmations, and time lock.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
constructor (
address[] memory _owners,
uint256 _required,
uint256 _secondsTimeLocked
)
public
MultiSigWallet(_owners, _required)
{
secondsTimeLocked = _secondsTimeLocked;
}
/// @dev Changes the duration of the time lock for transactions.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
function changeTimeLock(uint256 _secondsTimeLocked)
public
onlyWallet
{
secondsTimeLocked = _secondsTimeLocked;
emit TimeLockChange(_secondsTimeLocked);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint256 transactionId)
public
override
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
bool isTxFullyConfirmedBeforeConfirmation = isConfirmed(transactionId);
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
if (!isTxFullyConfirmedBeforeConfirmation && isConfirmed(transactionId)) {
_setConfirmationTime(transactionId, block.timestamp);
}
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint256 transactionId)
public
override
notExecuted(transactionId)
fullyConfirmed(transactionId)
pastTimeLock(transactionId)
{
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data)) {
emit Execution(transactionId);
} else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
/// @dev Sets the time of when a submission first passed.
function _setConfirmationTime(uint256 transactionId, uint256 confirmationTime)
internal
{
confirmationTimes[transactionId] = confirmationTime;
emit ConfirmationTimeSet(transactionId, confirmationTime);
}
}
pragma solidity ^0.6.12;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
/*
* Constants
*/
uint constant public MAX_OWNER_COUNT = 50;
/*
* Storage
*/
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != address(0));
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != address(0));
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
/// @dev Fallback function allows to deposit ether.
fallback()
external
payable
{
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
/*
* Public functions
*/
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor(address[] memory _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != address(0));
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.pop();
if (required > owners.length)
changeRequirement(owners.length);
emit OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
emit RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return transactionId Returns transaction ID.
function submitTransaction(address destination, uint value, bytes memory data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
virtual
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
virtual
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint value, uint dataLength, bytes memory data) internal returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(
sub(gas(), 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero
)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
view
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/*
* Internal functions
*/
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return transactionId Returns transaction ID.
function addTransaction(address destination, uint value, bytes memory data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
/*
* Web3 call functions
*/
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return count Number of confirmations.
function getConfirmationCount(uint transactionId)
public
view
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return count Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
view
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
view
returns (address[] memory)
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return _confirmations Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
view
returns (address[] memory _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return _transactionIds Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
view
returns (uint[] memory _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import {Math} from "@openzeppelin/contracts/math/Math.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {FixedPointMath} from "../FixedPointMath.sol";
import {IDetailedERC20} from "../../interfaces/IDetailedERC20.sol";
import {Round} from "./Round.sol";
/// @title Stake
///
/// @dev A library which provides the Stake data struct and associated functions.
library Stake {
using FixedPointMath for FixedPointMath.FixedDecimal;
using Round for Round.Data;
using SafeMath for uint256;
using Stake for Stake.Data;
struct Data {
uint256 totalDeposited;
uint256 totalWeightedTime;
uint256 lastUpdateTime;
bool claimed;
}
function update(Data storage _self) internal {
_self.totalWeightedTime = _self.getUpdatedTotalWeightedTime();
_self.lastUpdateTime = block.timestamp;
}
function getExchangedBalance(Data storage _self, Round.Data storage _round) internal view returns (uint256) {
FixedPointMath.FixedDecimal memory _distributeWeight = _round.getDistributeWeight();
FixedPointMath.FixedDecimal memory _exchangedBalance = _distributeWeight.mul(_self.totalDeposited);
return _exchangedBalance.decode();
}
function getUnexchangedBalance(Data storage _self, Round.Data storage _round) internal view returns (uint256) {
return _self.totalDeposited.sub(_self.getExchangedBalance(_round));
}
function getRemainingLockupTime(Data storage _self, Round.Data storage _round) internal view returns (uint256) {
uint256 _requiredWeightedTime = _self.getRequiredTotalWeightedTime(_round);
uint256 _totalWeightedTime = _self.getUpdatedTotalWeightedTime();
if (_totalWeightedTime >= _requiredWeightedTime) {
return 0;
}
uint256 _difference = _requiredWeightedTime.sub(_totalWeightedTime);
uint256 _totalDeposited = _self.totalDeposited;
if (_totalDeposited == 0) {
return 0;
}
return _difference.div(_totalDeposited);
}
function getRequiredTotalWeightedTime(Data storage _self, Round.Data storage _round) internal view returns (uint256) {
return _self.totalDeposited.mul(_round.lockupDuration);
}
function getUpdatedTotalWeightedTime(Data storage _self) internal view returns (uint256) {
uint256 _elapsedTime = block.timestamp.sub(_self.lastUpdateTime);
if (_elapsedTime == 0) {
return _self.totalWeightedTime;
}
uint256 _weightedTime = _self.totalDeposited.mul(_elapsedTime);
return _self.totalWeightedTime.add(_weightedTime);
}
function isUnlocked(Data storage _self, Round.Data storage _round) internal view returns (bool) {
uint256 _requiredWeightedTime = _self.getRequiredTotalWeightedTime(_round);
uint256 _totalWeightedTime = _self.getUpdatedTotalWeightedTime();
return _totalWeightedTime >= _requiredWeightedTime;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import {Math} from "@openzeppelin/contracts/math/Math.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {FixedPointMath} from "../FixedPointMath.sol";
import {IDetailedERC20} from "../../interfaces/IDetailedERC20.sol";
library Round {
using FixedPointMath for FixedPointMath.FixedDecimal;
using Round for Data;
using Round for List;
using SafeMath for uint256;
struct Data {
uint256 availableBalance;
uint256 commitEndTime;
uint256 lockupDuration;
uint256 totalDeposited;
}
struct List {
Data[] elements;
}
/// @dev Gets if the round has been completed.
///
/// @return if the current time is equal to or after the round's end time.
function isCommitPhaseComplete(Data storage _self) internal view returns (bool) {
return block.timestamp >= _self.commitEndTime;
}
/// @dev Gets the current amount of tokens to distribute per token staked.
///
/// @return the distribute weight.
function getDistributeWeight(Data storage _self) internal view returns (FixedPointMath.FixedDecimal memory) {
FixedPointMath.FixedDecimal memory _weight = FixedPointMath.fromU256(_self.getDistributeBalance());
return _weight.div(_self.totalDeposited);
}
/// @dev Gets the amount to distribute to stakers.
///
/// @return the amount to distribute.
function getDistributeBalance(Data storage _self) internal view returns (uint256) {
return Math.min(_self.availableBalance, _self.totalDeposited);
}
/// @dev Gets the amount to distribute in the next round.
///
/// @return the runoff amount.
function getRunoffBalance(Data storage _self) internal view returns (uint256) {
return _self.availableBalance.sub(_self.getDistributeBalance());
}
/// @dev Adds a round to the list.
///
/// @param _element the element to add.
function push(List storage _self, Data memory _element) internal {
_self.elements.push(_element);
}
/// @dev Gets a element from the list.
///
/// @param _index the index in the list.
///
/// @return the element at the specified index.
function get(List storage _self, uint256 _index) internal view returns (Data storage) {
return _self.elements[_index];
}
/// @dev Gets the last element in the list.
///
/// This function will revert if there are no elements in the list.
///
/// @return the last element in the list.
function last(List storage _self) internal view returns (Data storage) {
return _self.elements[_self.lastIndex()];
}
/// @dev Gets the index of the last element in the list.
///
/// This function will revert if there are no elements in the list.
///
/// @return the index of the last element.
function lastIndex(List storage _self) internal view returns (uint256) {
uint256 _length = _self.length();
return _length.sub(1, "Round.List: list is empty");
}
/// @dev Gets the number of elements in the list.
///
/// @return the number of elements.
function length(List storage _self) internal view returns (uint256) {
return _self.elements.length;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Math} from "@openzeppelin/contracts/math/Math.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {FixedPointMath} from "../FixedPointMath.sol";
import {IDetailedERC20} from "../../interfaces/IDetailedERC20.sol";
library Vault {
using FixedPointMath for FixedPointMath.FixedDecimal;
using Vault for Data;
using Vault for List;
using SafeMath for uint256;
struct Data {
IERC20 token;
address owner;
uint256 lockedAmount;
uint256 totalClaimed;
uint256 startTime;
uint256 endTime;
}
struct List {
Data[] elements;
}
/// @dev Gets the duration of the vesting period.
///
/// @return the duration of the vesting period in seconds.
function getDuration(Data storage _self) internal view returns (uint256) {
return _self.endTime.sub(_self.startTime);
}
/// @dev Gets the amount of tokens that have been released up to the current moment.
///
/// @return the released amount of tokens.
function getReleasedAmount(Data storage _self) internal view returns (uint256) {
if (block.timestamp < _self.startTime) {
return 0;
}
uint256 _lowerTime = block.timestamp;
uint256 _upperTime = Math.min(block.timestamp, _self.endTime);
uint256 _elapsedTime = _upperTime.sub(_lowerTime);
uint256 _numerator = _self.lockedAmount.mul(_elapsedTime);
uint256 _denominator = _self.getDuration();
return _numerator.div(_denominator);
}
/// @dev Gets the amount of tokens that are available to be claimed from a vault.
///
/// @return the available amount of tokens.
function getAvailableAmount(Data storage _self) internal view returns (uint256) {
uint256 _releasedAmount = _self.getReleasedAmount();
return _releasedAmount.sub(_self.totalClaimed);
}
/// @dev Adds a round to the list.
///
/// @param _element the element to add.
function push(List storage _self, Data memory _element) internal {
_self.elements.push(_element);
}
/// @dev Gets a element from the list.
///
/// @param _index the index in the list.
///
/// @return the element at the specified index.
function get(List storage _self, uint256 _index) internal view returns (Data storage) {
return _self.elements[_index];
}
/// @dev Gets the last element in the list.
///
/// This function will revert if there are no elements in the list.
///
/// @return the last element in the list.
function last(List storage _self) internal view returns (Data storage) {
return _self.elements[_self.lastIndex()];
}
/// @dev Gets the index of the last element in the list.
///
/// This function will revert if there are no elements in the list.
///
/// @return the index of the last element.
function lastIndex(List storage _self) internal view returns (uint256) {
uint256 _length = _self.length();
return _length.sub(1, "Vault.List: list is empty");
}
/// @dev Gets the number of elements in the list.
///
/// @return the number of elements.
function length(List storage _self) internal view returns (uint256) {
return _self.elements.length;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
//import "hardhat/console.sol";
import {Math} from "@openzeppelin/contracts/math/Math.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {IDetailedERC20} from "../../interfaces/IDetailedERC20.sol";
import {IVaultAdapter} from "../../interfaces/IVaultAdapter.sol";
import "hardhat/console.sol";
/// @title Pool
///
/// @dev A library which provides the Vault data struct and associated functions.
library Vault {
using Vault for Data;
using Vault for List;
using SafeERC20 for IDetailedERC20;
using SafeMath for uint256;
struct Data {
IVaultAdapter adapter;
uint256 totalDeposited;
}
struct List {
Data[] elements;
}
/// @dev Gets the total amount of assets deposited in the vault.
///
/// @return the total assets.
function totalValue(Data storage _self) internal view returns (uint256) {
return _self.adapter.totalValue();
}
/// @dev Gets the token that the vault accepts.
///
/// @return the accepted token.
function token(Data storage _self) internal view returns (IDetailedERC20) {
return IDetailedERC20(_self.adapter.token());
}
/// @dev Deposits funds from the caller into the vault.
///
/// @param _amount the amount of funds to deposit.
function deposit(Data storage _self, uint256 _amount) internal returns (uint256) {
// Push the token that the vault accepts onto the stack to save gas.
IDetailedERC20 _token = _self.token();
_token.safeTransfer(address(_self.adapter), _amount);
_self.adapter.deposit(_amount);
_self.totalDeposited = _self.totalDeposited.add(_amount);
return _amount;
}
/// @dev Deposits the entire token balance of the caller into the vault.
function depositAll(Data storage _self) internal returns (uint256) {
IDetailedERC20 _token = _self.token();
return _self.deposit(_token.balanceOf(address(this)));
}
/// @dev Withdraw deposited funds from the vault.
///
/// @param _recipient the account to withdraw the tokens to.
/// @param _amount the amount of tokens to withdraw.
function withdraw(Data storage _self, address _recipient, uint256 _amount) internal returns (uint256, uint256) {
(uint256 _withdrawnAmount, uint256 _decreasedValue) = _self.directWithdraw(_recipient, _amount);
_self.totalDeposited = _self.totalDeposited.sub(_decreasedValue);
return (_withdrawnAmount, _decreasedValue);
}
/// @dev Directly withdraw deposited funds from the vault.
///
/// @param _recipient the account to withdraw the tokens to.
/// @param _amount the amount of tokens to withdraw.
function directWithdraw(Data storage _self, address _recipient, uint256 _amount) internal returns (uint256, uint256) {
IDetailedERC20 _token = _self.token();
uint256 _startingBalance = _token.balanceOf(_recipient);
uint256 _startingTotalValue = _self.totalValue();
_self.adapter.withdraw(_recipient, _amount);
uint256 _endingBalance = _token.balanceOf(_recipient);
uint256 _withdrawnAmount = _endingBalance.sub(_startingBalance);
uint256 _endingTotalValue = _self.totalValue();
uint256 _decreasedValue = _startingTotalValue.sub(_endingTotalValue);
return (_withdrawnAmount, _decreasedValue);
}
/// @dev Withdraw all the deposited funds from the vault.
///
/// @param _recipient the account to withdraw the tokens to.
function withdrawAll(Data storage _self, address _recipient) internal returns (uint256, uint256) {
return _self.withdraw(_recipient, _self.totalDeposited);
}
/// @dev Harvests yield from the vault.
///
/// @param _recipient the account to withdraw the harvested yield to.
function harvest(Data storage _self, address _recipient) internal returns (uint256, uint256) {
if (_self.totalValue() <= _self.totalDeposited) {
return (0, 0);
}
uint256 _withdrawAmount = _self.totalValue().sub(_self.totalDeposited);
return _self.directWithdraw(_recipient, _withdrawAmount);
}
/// @dev Adds a element to the list.
///
/// @param _element the element to add.
function push(List storage _self, Data memory _element) internal {
_self.elements.push(_element);
}
/// @dev Gets a element from the list.
///
/// @param _index the index in the list.
///
/// @return the element at the specified index.
function get(List storage _self, uint256 _index) internal view returns (Data storage) {
return _self.elements[_index];
}
/// @dev Gets the last element in the list.
///
/// This function will revert if there are no elements in the list.
///
/// @return the last element in the list.
function last(List storage _self) internal view returns (Data storage) {
return _self.elements[_self.lastIndex()];
}
/// @dev Gets the index of the last element in the list.
///
/// This function will revert if there are no elements in the list.
///
/// @return the index of the last element.
function lastIndex(List storage _self) internal view returns (uint256) {
uint256 _length = _self.length();
return _length.sub(1, "Vault.List: empty");
}
/// @dev Gets the number of elements in the list.
///
/// @return the number of elements.
function length(List storage _self) internal view returns (uint256) {
return _self.elements.length;
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
//import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Math} from "@openzeppelin/contracts/math/Math.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {CDP} from "./libraries/alchemist/CDP.sol";
import {FixedPointMath} from "./libraries/FixedPointMath.sol";
import {ITransmuter} from "./interfaces/ITransmuter.sol";
import {IMintableERC20} from "./interfaces/IMintableERC20.sol";
import {IChainlink} from "./interfaces/IChainlink.sol";
import {IVaultAdapter} from "./interfaces/IVaultAdapter.sol";
import {Vault} from "./libraries/alchemist/Vault.sol";
import "hardhat/console.sol";
// ERC20,removing ERC20 from the alchemist
// ___ __ __ _ ___ __ _
// / _ | / / ____ / / ___ __ _ (_) __ __ / _ \ ____ ___ ___ ___ ___ / /_ ___ (_)
// / __ | / / / __/ / _ \/ -_) / ' \ / / \ \ / / ___/ / __// -_) (_-</ -_) / _ \/ __/ (_-< _
// /_/ |_|/_/ \__/ /_//_/\__/ /_/_/_//_/ /_\_\ /_/ /_/ \__/ /___/\__/ /_//_/\__/ /___/(_)
//
// ___ __ ______ __ __ _______ .___ ___. __ _______..___________.
// / \ | | / || | | | | ____|| \/ | | | / || |
// / ^ \ | | | ,----'| |__| | | |__ | \ / | | | | (----``---| |----`
// / /_\ \ | | | | | __ | | __| | |\/| | | | \ \ | |
// / _____ \ | `----.| `----.| | | | | |____ | | | | | | .----) | | |
// /__/ \__\ |_______| \______||__| |__| |_______||__| |__| |__| |_______/ |__|
contract Alchemist is ReentrancyGuard {
using CDP for CDP.Data;
using FixedPointMath for FixedPointMath.FixedDecimal;
using Vault for Vault.Data;
using Vault for Vault.List;
using SafeERC20 for IMintableERC20;
using SafeMath for uint256;
using Address for address;
address public constant ZERO_ADDRESS = address(0);
/// @dev Resolution for all fixed point numeric parameters which represent percents. The resolution allows for a
/// granularity of 0.01% increments.
uint256 public constant PERCENT_RESOLUTION = 10000;
/// @dev The minimum value that the collateralization limit can be set to by the governance. This is a safety rail
/// to prevent the collateralization from being set to a value which breaks the system.
///
/// This value is equal to 100%.
///
/// IMPORTANT: This constant is a raw FixedPointMath.FixedDecimal value and assumes a resolution of 64 bits. If the
/// resolution for the FixedPointMath library changes this constant must change as well.
uint256 public constant MINIMUM_COLLATERALIZATION_LIMIT = 1000000000000000000;
/// @dev The maximum value that the collateralization limit can be set to by the governance. This is a safety rail
/// to prevent the collateralization from being set to a value which breaks the system.
///
/// This value is equal to 400%.
///
/// IMPORTANT: This constant is a raw FixedPointMath.FixedDecimal value and assumes a resolution of 64 bits. If the
/// resolution for the FixedPointMath library changes this constant must change as well.
uint256 public constant MAXIMUM_COLLATERALIZATION_LIMIT = 4000000000000000000;
event GovernanceUpdated(
address governance
);
event PendingGovernanceUpdated(
address pendingGovernance
);
event SentinelUpdated(
address sentinel
);
event TransmuterUpdated(
address transmuter
);
event RewardsUpdated(
address treasury
);
event HarvestFeeUpdated(
uint256 fee
);
event CollateralizationLimitUpdated(
uint256 limit
);
event EmergencyExitUpdated(
bool status
);
event ActiveVaultUpdated(
IVaultAdapter indexed adapter
);
event FundsHarvested(
uint256 withdrawnAmount,
uint256 decreasedValue
);
event FundsRecalled(
uint256 indexed vaultId,
uint256 withdrawnAmount,
uint256 decreasedValue
);
event FundsFlushed(
uint256 amount
);
event TokensDeposited(
address indexed account,
uint256 amount
);
event TokensWithdrawn(
address indexed account,
uint256 requestedAmount,
uint256 withdrawnAmount,
uint256 decreasedValue
);
event TokensRepaid(
address indexed account,
uint256 parentAmount,
uint256 childAmount
);
event TokensLiquidated(
address indexed account,
uint256 requestedAmount,
uint256 withdrawnAmount,
uint256 decreasedValue
);
/// @dev The token that this contract is using as the parent asset.
IMintableERC20 public token;
/// @dev The token that this contract is using as the child asset.
IMintableERC20 public xtoken;
/// @dev The address of the account which currently has administrative capabilities over this contract.
address public governance;
/// @dev The address of the pending governance.
address public pendingGovernance;
/// @dev The address of the account which can initiate an emergency withdraw of funds in a vault.
address public sentinel;
/// @dev The address of the contract which will transmute synthetic tokens back into native tokens.
address public transmuter;
/// @dev The address of the contract which will receive fees.
address public rewards;
/// @dev The percent of each profitable harvest that will go to the rewards contract.
uint256 public harvestFee;
/// @dev The total amount the native token deposited into the system that is owned by external users.
uint256 public totalDeposited;
/// @dev when movemetns are bigger than this number flush is activated.
uint256 public flushActivator;
/// @dev A flag indicating if the contract has been initialized yet.
bool public initialized;
/// @dev A flag indicating if deposits and flushes should be halted and if all parties should be able to recall
/// from the active vault.
bool public emergencyExit;
/// @dev The context shared between the CDPs.
CDP.Context private _ctx;
/// @dev A mapping of all of the user CDPs. If a user wishes to have multiple CDPs they will have to either
/// create a new address or set up a proxy contract that interfaces with this contract.
mapping(address => CDP.Data) private _cdps;
/// @dev A list of all of the vaults. The last element of the list is the vault that is currently being used for
/// deposits and withdraws. Vaults before the last element are considered inactive and are expected to be cleared.
Vault.List private _vaults;
/// @dev The address of the link oracle.
address public _linkGasOracle;
/// @dev The minimum returned amount needed to be on peg according to the oracle.
uint256 public pegMinimum;
constructor(
IMintableERC20 _token,
IMintableERC20 _xtoken,
address _governance,
address _sentinel
)
public
/*ERC20(
string(abi.encodePacked("Alchemic ", _token.name())),
string(abi.encodePacked("al", _token.symbol()))
)*/
{
require(_governance != ZERO_ADDRESS, "Alchemist: governance address cannot be 0x0.");
require(_sentinel != ZERO_ADDRESS, "Alchemist: sentinel address cannot be 0x0.");
token = _token;
xtoken = _xtoken;
governance = _governance;
sentinel = _sentinel;
flushActivator = 100000 ether;// change for non 18 digit tokens
//_setupDecimals(_token.decimals());
uint256 COLL_LIMIT = MINIMUM_COLLATERALIZATION_LIMIT.mul(2);
_ctx.collateralizationLimit = FixedPointMath.FixedDecimal(COLL_LIMIT);
_ctx.accumulatedYieldWeight = FixedPointMath.FixedDecimal(0);
}
/// @dev Sets the pending governance.
///
/// This function reverts if the new pending governance is the zero address or the caller is not the current
/// governance. This is to prevent the contract governance being set to the zero address which would deadlock
/// privileged contract functionality.
///
/// @param _pendingGovernance the new pending governance.
function setPendingGovernance(address _pendingGovernance) external onlyGov {
require(_pendingGovernance != ZERO_ADDRESS, "Alchemist: governance address cannot be 0x0.");
pendingGovernance = _pendingGovernance;
emit PendingGovernanceUpdated(_pendingGovernance);
}
/// @dev Accepts the role as governance.
///
/// This function reverts if the caller is not the new pending governance.
function acceptGovernance() external {
require(msg.sender == pendingGovernance,"sender is not pendingGovernance");
address _pendingGovernance = pendingGovernance;
governance = _pendingGovernance;
emit GovernanceUpdated(_pendingGovernance);
}
function setSentinel(address _sentinel) external onlyGov {
require(_sentinel != ZERO_ADDRESS, "Alchemist: sentinel address cannot be 0x0.");
sentinel = _sentinel;
emit SentinelUpdated(_sentinel);
}
/// @dev Sets the transmuter.
///
/// This function reverts if the new transmuter is the zero address or the caller is not the current governance.
///
/// @param _transmuter the new transmuter.
function setTransmuter(address _transmuter) external onlyGov {
// Check that the transmuter address is not the zero address. Setting the transmuter to the zero address would break
// transfers to the address because of `safeTransfer` checks.
require(_transmuter != ZERO_ADDRESS, "Alchemist: transmuter address cannot be 0x0.");
transmuter = _transmuter;
emit TransmuterUpdated(_transmuter);
}
/// @dev Sets the flushActivator.
///
/// @param _flushActivator the new flushActivator.
function setFlushActivator(uint256 _flushActivator) external onlyGov {
flushActivator = _flushActivator;
}
/// @dev Sets the rewards contract.
///
/// This function reverts if the new rewards contract is the zero address or the caller is not the current governance.
///
/// @param _rewards the new rewards contract.
function setRewards(address _rewards) external onlyGov {
// Check that the rewards address is not the zero address. Setting the rewards to the zero address would break
// transfers to the address because of `safeTransfer` checks.
require(_rewards != ZERO_ADDRESS, "Alchemist: rewards address cannot be 0x0.");
rewards = _rewards;
emit RewardsUpdated(_rewards);
}
/// @dev Sets the harvest fee.
///
/// This function reverts if the caller is not the current governance.
///
/// @param _harvestFee the new harvest fee.
function setHarvestFee(uint256 _harvestFee) external onlyGov {
// Check that the harvest fee is within the acceptable range. Setting the harvest fee greater than 100% could
// potentially break internal logic when calculating the harvest fee.
require(_harvestFee <= PERCENT_RESOLUTION, "Alchemist: harvest fee above maximum.");
harvestFee = _harvestFee;
emit HarvestFeeUpdated(_harvestFee);
}
/// @dev Sets the collateralization limit.
///
/// This function reverts if the caller is not the current governance or if the collateralization limit is outside
/// of the accepted bounds.
///
/// @param _limit the new collateralization limit.
function setCollateralizationLimit(uint256 _limit) external onlyGov {
require(_limit >= MINIMUM_COLLATERALIZATION_LIMIT, "Alchemist: collateralization limit below minimum.");
require(_limit <= MAXIMUM_COLLATERALIZATION_LIMIT, "Alchemist: collateralization limit above maximum.");
_ctx.collateralizationLimit = FixedPointMath.FixedDecimal(_limit);
emit CollateralizationLimitUpdated(_limit);
}
/// @dev Set oracle.
function setOracleAddress(address Oracle, uint256 peg) external onlyGov {
_linkGasOracle = Oracle;
pegMinimum = peg;
}
/// @dev Sets if the contract should enter emergency exit mode.
///
/// @param _emergencyExit if the contract should enter emergency exit mode.
function setEmergencyExit(bool _emergencyExit) external {
require(msg.sender == governance || msg.sender == sentinel, "");
emergencyExit = _emergencyExit;
emit EmergencyExitUpdated(_emergencyExit);
}
/// @dev Gets the collateralization limit.
///
/// The collateralization limit is the minimum ratio of collateral to debt that is allowed by the system.
///
/// @return the collateralization limit.
function collateralizationLimit() external view returns (FixedPointMath.FixedDecimal memory) {
return _ctx.collateralizationLimit;
}
/// @dev Initializes the contract.
///
/// This function checks that the transmuter and rewards have been set and sets up the active vault.
///
/// @param _adapter the vault adapter of the active vault.
function initialize(IVaultAdapter _adapter) external onlyGov {
require(!initialized, "Alchemist: already initialized");
require(transmuter != ZERO_ADDRESS, "Alchemist: cannot initialize transmuter address to 0x0");
require(rewards != ZERO_ADDRESS, "Alchemist: cannot initialize rewards address to 0x0");
_updateActiveVault(_adapter);
initialized = true;
}
/// @dev Migrates the system to a new vault.
///
/// This function reverts if the vault adapter is the zero address, if the token that the vault adapter accepts
/// is not the token that this contract defines as the parent asset, or if the contract has not yet been initialized.
///
/// @param _adapter the adapter for the vault the system will migrate to.
function migrate(IVaultAdapter _adapter) external expectInitialized onlyGov {
_updateActiveVault(_adapter);
}
/// @dev Harvests yield from a vault.
///
/// @param _vaultId the identifier of the vault to harvest from.
///
/// @return the amount of funds that were harvested from the vault.
function harvest(uint256 _vaultId) external expectInitialized returns (uint256, uint256) {
Vault.Data storage _vault = _vaults.get(_vaultId);
(uint256 _harvestedAmount, uint256 _decreasedValue) = _vault.harvest(address(this));
if (_harvestedAmount > 0) {
uint256 _feeAmount = _harvestedAmount.mul(harvestFee).div(PERCENT_RESOLUTION);
uint256 _distributeAmount = _harvestedAmount.sub(_feeAmount);
FixedPointMath.FixedDecimal memory _weight = FixedPointMath.fromU256(_distributeAmount).div(totalDeposited);
_ctx.accumulatedYieldWeight = _ctx.accumulatedYieldWeight.add(_weight);
if (_feeAmount > 0) {
token.safeTransfer(rewards, _feeAmount);
}
if (_distributeAmount > 0) {
_distributeToTransmuter(_distributeAmount);
// token.safeTransfer(transmuter, _distributeAmount); previous version call
}
}
emit FundsHarvested(_harvestedAmount, _decreasedValue);
return (_harvestedAmount, _decreasedValue);
}
/// @dev Recalls an amount of deposited funds from a vault to this contract.
///
/// @param _vaultId the identifier of the recall funds from.
///
/// @return the amount of funds that were recalled from the vault to this contract and the decreased vault value.
function recall(uint256 _vaultId, uint256 _amount) external nonReentrant expectInitialized returns (uint256, uint256) {
return _recallFunds(_vaultId, _amount);
}
/// @dev Recalls all the deposited funds from a vault to this contract.
///
/// @param _vaultId the identifier of the recall funds from.
///
/// @return the amount of funds that were recalled from the vault to this contract and the decreased vault value.
function recallAll(uint256 _vaultId) external nonReentrant expectInitialized returns (uint256, uint256) {
Vault.Data storage _vault = _vaults.get(_vaultId);
return _recallFunds(_vaultId, _vault.totalDeposited);
}
/// @dev Flushes buffered tokens to the active vault.
///
/// This function reverts if an emergency exit is active. This is in place to prevent the potential loss of
/// additional funds.
///
/// @return the amount of tokens flushed to the active vault.
function flush() external nonReentrant expectInitialized returns (uint256) {
// Prevent flushing to the active vault when an emergency exit is enabled to prevent potential loss of funds if
// the active vault is poisoned for any reason.
require(!emergencyExit, "emergency pause enabled");
return flushActiveVault();
}
/// @dev Internal function to flush buffered tokens to the active vault.
///
/// This function reverts if an emergency exit is active. This is in place to prevent the potential loss of
/// additional funds.
///
/// @return the amount of tokens flushed to the active vault.
function flushActiveVault() internal returns (uint256) {
Vault.Data storage _activeVault = _vaults.last();
uint256 _depositedAmount = _activeVault.depositAll();
emit FundsFlushed(_depositedAmount);
return _depositedAmount;
}
/// @dev Deposits collateral into a CDP.
///
/// This function reverts if an emergency exit is active. This is in place to prevent the potential loss of
/// additional funds.
///
/// @param _amount the amount of collateral to deposit.
function deposit(uint256 _amount) external nonReentrant noContractAllowed expectInitialized {
require(!emergencyExit, "emergency pause enabled");
CDP.Data storage _cdp = _cdps[msg.sender];
_cdp.update(_ctx);
token.safeTransferFrom(msg.sender, address(this), _amount);
if(_amount >= flushActivator) {
flushActiveVault();
}
totalDeposited = totalDeposited.add(_amount);
_cdp.totalDeposited = _cdp.totalDeposited.add(_amount);
_cdp.lastDeposit = block.number;
emit TokensDeposited(msg.sender, _amount);
}
/// @dev Attempts to withdraw part of a CDP's collateral.
///
/// This function reverts if a deposit into the CDP was made in the same block. This is to prevent flash loan attacks
/// on other internal or external systems.
///
/// @param _amount the amount of collateral to withdraw.
function withdraw(uint256 _amount) external nonReentrant noContractAllowed expectInitialized returns (uint256, uint256) {
CDP.Data storage _cdp = _cdps[msg.sender];
require(block.number > _cdp.lastDeposit, "");
_cdp.update(_ctx);
(uint256 _withdrawnAmount, uint256 _decreasedValue) = _withdrawFundsTo(msg.sender, _amount);
_cdp.totalDeposited = _cdp.totalDeposited.sub(_decreasedValue, "Exceeds withdrawable amount");
_cdp.checkHealth(_ctx, "Action blocked: unhealthy collateralization ratio");
if(_amount >= flushActivator) {
flushActiveVault();
}
emit TokensWithdrawn(msg.sender, _amount, _withdrawnAmount, _decreasedValue);
return (_withdrawnAmount, _decreasedValue);
}
/// @dev Repays debt with the native and or synthetic token.
///
/// An approval is required to transfer native tokens to the transmuter.
function repay(uint256 _parentAmount, uint256 _childAmount) external nonReentrant noContractAllowed onLinkCheck expectInitialized {
CDP.Data storage _cdp = _cdps[msg.sender];
_cdp.update(_ctx);
if (_parentAmount > 0) {
token.safeTransferFrom(msg.sender, address(this), _parentAmount);
_distributeToTransmuter(_parentAmount);
}
if (_childAmount > 0) {
xtoken.burnFrom(msg.sender, _childAmount);
//lower debt cause burn
xtoken.lowerHasMinted(_childAmount);
}
uint256 _totalAmount = _parentAmount.add(_childAmount);
_cdp.totalDebt = _cdp.totalDebt.sub(_totalAmount, "");
emit TokensRepaid(msg.sender, _parentAmount, _childAmount);
}
/// @dev Attempts to liquidate part of a CDP's collateral to pay back its debt.
///
/// @param _amount the amount of collateral to attempt to liquidate.
function liquidate(uint256 _amount) external nonReentrant noContractAllowed onLinkCheck expectInitialized returns (uint256, uint256) {
CDP.Data storage _cdp = _cdps[msg.sender];
_cdp.update(_ctx);
// don't attempt to liquidate more than is possible
if(_amount > _cdp.totalDebt){
_amount = _cdp.totalDebt;
}
(uint256 _withdrawnAmount, uint256 _decreasedValue) = _withdrawFundsTo(address(this), _amount);
//changed to new transmuter compatibillity
_distributeToTransmuter(_withdrawnAmount);
_cdp.totalDeposited = _cdp.totalDeposited.sub(_decreasedValue, "");
_cdp.totalDebt = _cdp.totalDebt.sub(_withdrawnAmount, "");
emit TokensLiquidated(msg.sender, _amount, _withdrawnAmount, _decreasedValue);
return (_withdrawnAmount, _decreasedValue);
}
/// @dev Mints synthetic tokens by either claiming credit or increasing the debt.
///
/// Claiming credit will take priority over increasing the debt.
///
/// This function reverts if the debt is increased and the CDP health check fails.
///
/// @param _amount the amount of alchemic tokens to borrow.
function mint(uint256 _amount) external nonReentrant noContractAllowed onLinkCheck expectInitialized {
CDP.Data storage _cdp = _cdps[msg.sender];
_cdp.update(_ctx);
uint256 _totalCredit = _cdp.totalCredit;
if (_totalCredit < _amount) {
uint256 _remainingAmount = _amount.sub(_totalCredit);
_cdp.totalDebt = _cdp.totalDebt.add(_remainingAmount);
_cdp.totalCredit = 0;
_cdp.checkHealth(_ctx, "Alchemist: Loan-to-value ratio breached");
} else {
_cdp.totalCredit = _totalCredit.sub(_amount);
}
xtoken.mint(msg.sender, _amount);
if(_amount >= flushActivator) {
flushActiveVault();
}
}
/// @dev Gets the number of vaults in the vault list.
///
/// @return the vault count.
function vaultCount() external view returns (uint256) {
return _vaults.length();
}
/// @dev Get the adapter of a vault.
///
/// @param _vaultId the identifier of the vault.
///
/// @return the vault adapter.
function getVaultAdapter(uint256 _vaultId) external view returns (IVaultAdapter) {
Vault.Data storage _vault = _vaults.get(_vaultId);
return _vault.adapter;
}
/// @dev Get the total amount of the parent asset that has been deposited into a vault.
///
/// @param _vaultId the identifier of the vault.
///
/// @return the total amount of deposited tokens.
function getVaultTotalDeposited(uint256 _vaultId) external view returns (uint256) {
Vault.Data storage _vault = _vaults.get(_vaultId);
return _vault.totalDeposited;
}
/// @dev Get the total amount of collateral deposited into a CDP.
///
/// @param _account the user account of the CDP to query.
///
/// @return the deposited amount of tokens.
function getCdpTotalDeposited(address _account) external view returns (uint256) {
CDP.Data storage _cdp = _cdps[_account];
return _cdp.totalDeposited;
}
/// @dev Get the total amount of alchemic tokens borrowed from a CDP.
///
/// @param _account the user account of the CDP to query.
///
/// @return the borrowed amount of tokens.
function getCdpTotalDebt(address _account) external view returns (uint256) {
CDP.Data storage _cdp = _cdps[_account];
return _cdp.getUpdatedTotalDebt(_ctx);
}
/// @dev Get the total amount of credit that a CDP has.
///
/// @param _account the user account of the CDP to query.
///
/// @return the amount of credit.
function getCdpTotalCredit(address _account) external view returns (uint256) {
CDP.Data storage _cdp = _cdps[_account];
return _cdp.getUpdatedTotalCredit(_ctx);
}
/// @dev Gets the last recorded block of when a user made a deposit into their CDP.
///
/// @param _account the user account of the CDP to query.
///
/// @return the block number of the last deposit.
function getCdpLastDeposit(address _account) external view returns (uint256) {
CDP.Data storage _cdp = _cdps[_account];
return _cdp.lastDeposit;
}
/// @dev sends tokens to the transmuter
///
/// benefit of great nation of transmuter
function _distributeToTransmuter(uint256 amount) internal {
token.approve(transmuter,amount);
ITransmuter(transmuter).distribute(address(this),amount);
// lower debt cause of 'burn'
xtoken.lowerHasMinted(amount);
}
/// @dev Checks that parent token is on peg.
///
/// This is used over a modifier limit of pegged interactions.
modifier onLinkCheck() {
if(pegMinimum > 0 ){
uint256 oracleAnswer = uint256(IChainlink(_linkGasOracle).latestAnswer());
require(oracleAnswer > pegMinimum, "off peg limitation");
}
_;
}
/// @dev Checks that caller is not a eoa.
///
/// This is used to prevent contracts from interacting.
modifier noContractAllowed() {
require(!address(msg.sender).isContract() && msg.sender == tx.origin, "Sorry we do not accept contract!");
_;
}
/// @dev Checks that the contract is in an initialized state.
///
/// This is used over a modifier to reduce the size of the contract
modifier expectInitialized() {
require(initialized, "Alchemist: not initialized.");
_;
}
/// @dev Checks that the current message sender or caller is a specific address.
///
/// @param _expectedCaller the expected caller.
function _expectCaller(address _expectedCaller) internal {
require(msg.sender == _expectedCaller, "");
}
/// @dev Checks that the current message sender or caller is the governance address.
///
///
modifier onlyGov() {
require(msg.sender == governance, "Alchemist: only governance.");
_;
}
/// @dev Updates the active vault.
///
/// This function reverts if the vault adapter is the zero address, if the token that the vault adapter accepts
/// is not the token that this contract defines as the parent asset, or if the contract has not yet been initialized.
///
/// @param _adapter the adapter for the new active vault.
function _updateActiveVault(IVaultAdapter _adapter) internal {
require(_adapter != IVaultAdapter(ZERO_ADDRESS), "Alchemist: active vault address cannot be 0x0.");
require(_adapter.token() == token, "Alchemist: token mismatch.");
_vaults.push(Vault.Data({
adapter: _adapter,
totalDeposited: 0
}));
emit ActiveVaultUpdated(_adapter);
}
/// @dev Recalls an amount of funds from a vault to this contract.
///
/// @param _vaultId the identifier of the recall funds from.
/// @param _amount the amount of funds to recall from the vault.
///
/// @return the amount of funds that were recalled from the vault to this contract and the decreased vault value.
function _recallFunds(uint256 _vaultId, uint256 _amount) internal returns (uint256, uint256) {
require(emergencyExit || msg.sender == governance || _vaultId != _vaults.lastIndex(), "Alchemist: not an emergency, not governance, and user does not have permission to recall funds from active vault");
Vault.Data storage _vault = _vaults.get(_vaultId);
(uint256 _withdrawnAmount, uint256 _decreasedValue) = _vault.withdraw(address(this), _amount);
emit FundsRecalled(_vaultId, _withdrawnAmount, _decreasedValue);
return (_withdrawnAmount, _decreasedValue);
}
/// @dev Attempts to withdraw funds from the active vault to the recipient.
///
/// Funds will be first withdrawn from this contracts balance and then from the active vault. This function
/// is different from `recallFunds` in that it reduces the total amount of deposited tokens by the decreased
/// value of the vault.
///
/// @param _recipient the account to withdraw the funds to.
/// @param _amount the amount of funds to withdraw.
function _withdrawFundsTo(address _recipient, uint256 _amount) internal returns (uint256, uint256) {
// Pull the funds from the buffer.
uint256 _bufferedAmount = Math.min(_amount, token.balanceOf(address(this)));
if (_recipient != address(this)) {
token.safeTransfer(_recipient, _bufferedAmount);
}
uint256 _totalWithdrawn = _bufferedAmount;
uint256 _totalDecreasedValue = _bufferedAmount;
uint256 _remainingAmount = _amount.sub(_bufferedAmount);
// Pull the remaining funds from the active vault.
if (_remainingAmount > 0) {
Vault.Data storage _activeVault = _vaults.last();
(uint256 _withdrawAmount, uint256 _decreasedValue) = _activeVault.withdraw(
_recipient,
_remainingAmount
);
_totalWithdrawn = _totalWithdrawn.add(_withdrawAmount);
_totalDecreasedValue = _totalDecreasedValue.add(_decreasedValue);
}
totalDeposited = totalDeposited.sub(_totalDecreasedValue);
return (_totalWithdrawn, _totalDecreasedValue);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
import {Math} from "@openzeppelin/contracts/math/Math.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {FixedPointMath} from "../FixedPointMath.sol";
import {IDetailedERC20} from "../../interfaces/IDetailedERC20.sol";
import "hardhat/console.sol";
/// @title CDP
///
/// @dev A library which provides the CDP data struct and associated functions.
library CDP {
using CDP for Data;
using FixedPointMath for FixedPointMath.FixedDecimal;
using SafeERC20 for IDetailedERC20;
using SafeMath for uint256;
struct Context {
FixedPointMath.FixedDecimal collateralizationLimit;
FixedPointMath.FixedDecimal accumulatedYieldWeight;
}
struct Data {
uint256 totalDeposited;
uint256 totalDebt;
uint256 totalCredit;
uint256 lastDeposit;
FixedPointMath.FixedDecimal lastAccumulatedYieldWeight;
}
function update(Data storage _self, Context storage _ctx) internal {
uint256 _earnedYield = _self.getEarnedYield(_ctx);
if (_earnedYield > _self.totalDebt) {
uint256 _currentTotalDebt = _self.totalDebt;
_self.totalDebt = 0;
_self.totalCredit = _earnedYield.sub(_currentTotalDebt);
} else {
_self.totalDebt = _self.totalDebt.sub(_earnedYield);
}
_self.lastAccumulatedYieldWeight = _ctx.accumulatedYieldWeight;
}
/// @dev Assures that the CDP is healthy.
///
/// This function will revert if the CDP is unhealthy.
function checkHealth(Data storage _self, Context storage _ctx, string memory _msg) internal view {
require(_self.isHealthy(_ctx), _msg);
}
/// @dev Gets if the CDP is considered healthy.
///
/// A CDP is healthy if its collateralization ratio is greater than the global collateralization limit.
///
/// @return if the CDP is healthy.
function isHealthy(Data storage _self, Context storage _ctx) internal view returns (bool) {
return _ctx.collateralizationLimit.cmp(_self.getCollateralizationRatio(_ctx)) <= 0;
}
function getUpdatedTotalDebt(Data storage _self, Context storage _ctx) internal view returns (uint256) {
uint256 _unclaimedYield = _self.getEarnedYield(_ctx);
if (_unclaimedYield == 0) {
return _self.totalDebt;
}
uint256 _currentTotalDebt = _self.totalDebt;
if (_unclaimedYield >= _currentTotalDebt) {
return 0;
}
return _currentTotalDebt - _unclaimedYield;
}
function getUpdatedTotalCredit(Data storage _self, Context storage _ctx) internal view returns (uint256) {
uint256 _unclaimedYield = _self.getEarnedYield(_ctx);
if (_unclaimedYield == 0) {
return _self.totalCredit;
}
uint256 _currentTotalDebt = _self.totalDebt;
if (_unclaimedYield <= _currentTotalDebt) {
return 0;
}
return _self.totalCredit + (_unclaimedYield - _currentTotalDebt);
}
/// @dev Gets the amount of yield that a CDP has earned since the last time it was updated.
///
/// @param _self the CDP to query.
/// @param _ctx the CDP context.
///
/// @return the amount of earned yield.
function getEarnedYield(Data storage _self, Context storage _ctx) internal view returns (uint256) {
FixedPointMath.FixedDecimal memory _currentAccumulatedYieldWeight = _ctx.accumulatedYieldWeight;
FixedPointMath.FixedDecimal memory _lastAccumulatedYieldWeight = _self.lastAccumulatedYieldWeight;
if (_currentAccumulatedYieldWeight.cmp(_lastAccumulatedYieldWeight) == 0) {
return 0;
}
return _currentAccumulatedYieldWeight
.sub(_lastAccumulatedYieldWeight)
.mul(_self.totalDeposited)
.decode();
}
/// @dev Gets a CDPs collateralization ratio.
///
/// The collateralization ratio is defined as the ratio of collateral to debt. If the CDP has zero debt then this
/// will return the maximum value of a fixed point integer.
///
/// This function will use the updated total debt so an update before calling this function is not required.
///
/// @param _self the CDP to query.
///
/// @return a fixed point integer representing the collateralization ratio.
function getCollateralizationRatio(Data storage _self, Context storage _ctx)
internal view
returns (FixedPointMath.FixedDecimal memory)
{
uint256 _totalDebt = _self.getUpdatedTotalDebt(_ctx);
if (_totalDebt == 0) {
return FixedPointMath.maximumValue();
}
return FixedPointMath.fromU256(_self.totalDeposited).div(_totalDebt);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
interface ITransmuter {
function distribute (address origin, uint256 amount) external;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
interface IChainlink {
function latestAnswer() external view returns (int256);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IDetailedERC20} from "./interfaces/IDetailedERC20.sol";
/// @title AlchemixToken
///
/// @dev This is the contract for the Alchemix governance token.
///
/// Initially, the contract deployer is given both the admin and minter role. This allows them to pre-mine tokens,
/// transfer admin to a timelock contract, and lastly, grant the staking pools the minter role. After this is done,
/// the deployer must revoke their admin role and minter role.
contract AlchemixToken is AccessControl, ERC20("Alchemix", "ALCX") {
/// @dev The identifier of the role which maintains other roles.
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN");
/// @dev The identifier of the role which allows accounts to mint tokens.
bytes32 public constant MINTER_ROLE = keccak256("MINTER");
constructor() public {
_setupRole(ADMIN_ROLE, msg.sender);
_setupRole(MINTER_ROLE, msg.sender);
_setRoleAdmin(MINTER_ROLE, ADMIN_ROLE);
_setRoleAdmin(ADMIN_ROLE, ADMIN_ROLE);
}
/// @dev A modifier which checks that the caller has the minter role.
modifier onlyMinter() {
require(hasRole(MINTER_ROLE, msg.sender), "AlchemixToken: only minter");
_;
}
/// @dev Mints tokens to a recipient.
///
/// This function reverts if the caller does not have the minter role.
///
/// @param _recipient the account to mint tokens to.
/// @param _amount the amount of tokens to mint.
function mint(address _recipient, uint256 _amount) external onlyMinter {
_mint(_recipient, _amount);
}
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
/// @title ERC20Mock
///
/// @dev A mock of an ERC20 token which lets anyone burn and mint tokens.
contract ERC20Mock is ERC20 {
constructor(string memory _name, string memory _symbol, uint8 _decimals) public ERC20(_name, _symbol) {
_setupDecimals(_decimals);
}
function mint(address _recipient, uint256 _amount) external {
_mint(_recipient, _amount);
}
function burn(address _account, uint256 _amount) external {
_burn(_account, _amount);
}
} | @dev Adds an element to the list. @param _element the element to add. | function push(List storage _self, Data memory _element) internal {
_self.elements.push(_element);
}
| 94,392 | [
1,
3655,
392,
930,
358,
326,
666,
18,
225,
389,
2956,
326,
930,
358,
527,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
445,
1817,
12,
682,
2502,
389,
2890,
16,
1910,
3778,
389,
2956,
13,
2713,
288,
203,
565,
389,
2890,
18,
6274,
18,
6206,
24899,
2956,
1769,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./AccessExtension.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
/**
* @title Intelligent NFT Interface
* Version 1
*
* @notice External interface of IntelligentNFTv1 declared to support ERC165 detection.
* See Intelligent NFT documentation below.
*
* @author Basil Gorin
*/
interface IIntelligentNFTv1 {
function totalSupply() external view returns (uint256);
function exists(uint256 recordId) external view returns (bool);
function ownerOf(uint256 recordId) external view returns (address);
}
/**
* @title Intelligent NFT (iNFT)
* Version 1
*
* @notice Intelligent NFT (iNFT) represents an enhancement to an existing NFT
* (we call it a "target" or "target NFT"), it binds a GPT-3 prompt (a "personality prompt")
* to the target to embed intelligence, is controlled and belongs to the owner of the target.
*
* @notice iNFT stores AI Pod and some amount of ALI tokens locked, available to
* unlocking when iNFT is destroyed
*
* @notice iNFT is not an ERC721 token, but it has some very limited similarity to an ERC721:
* every record is identified by ID and this ID has an owner, which is effectively the target NFT owner;
* still, it doesn't store ownership information itself and fully relies on the target ownership instead
*
* @dev Internally iNFTs consist of:
* - personality prompt - a GPT-3 prompt defining its intelligent capabilities
* - target NFT - smart contract address and ID of the NFT the iNFT is bound to
* - AI Pod - ID of the AI Pod used to produce given iNFT, locked within an iNFT
* - ALI tokens amount - amount of the ALI tokens used to produce given iNFT, also locked
*
* @dev iNFTs can be
* - created, this process requires an AI Pod and ALI tokens to be locked
* - destroyed, this process releases an AI Pod and ALI tokens previously locked;
* ALI token fee may get withheld upon destruction
*
* @dev Some known limitations of Version 1:
* - doesn't support ERC1155 as a target NFT
* - only one-to-one iNFT-NFT bindings,
* no many-to-one, one-to-many, or many-to-many bindings not allowed
* - no AI Pod ID -> iNFT ID binding, impossible to look for iNFT by AI Pod ID
* - no enumeration support, iNFT IDs created must be tracked off-chain,
* or [recommended] generated with a predictable deterministic integer sequence,
* for example, 1, 2, 3, ...
* - no support for personality prompt upgrades (no way to update personality prompt)
* - burn: doesn't allow to specify where to send the iNFT burning fee, sends ALI tokens
* burner / transaction sender (iNFT Linker)
* - burn: doesn't verify if its safe to send ALI tokens released back to NFT owner;
* ALI tokens may get lost if iNFT is burnt when NFT belongs to a smart contract which
* is not aware of the ALI tokens being sent to it
* - no target NFT ID optimization; storage usage for IntelliBinding can be optimized
* if short target NFT IDs are recognized and stored optimized
* - AI Pod ERC721 and ALI ERC20 smart contracts are set during the deployment and cannot be changed
*
* @author Basil Gorin
*/
contract IntelligentNFTv1 is IIntelligentNFTv1, AccessExtension {
/**
* @notice Deployer is responsible for AI Pod and ALI tokens contract address initialization
*
* @dev Role ROLE_DEPLOYER allows executing `setPodContract` and `setAliContract` functions
*/
bytes32 public constant ROLE_DEPLOYER = keccak256("ROLE_DEPLOYER");
/**
* @notice Minter is responsible for creating (minting) iNFTs
*
* @dev Role ROLE_MINTER allows minting iNFTs (calling `mint` function)
*/
bytes32 public constant ROLE_MINTER = keccak256("ROLE_MINTER");
/**
* @notice Burner is responsible for destroying (burning) iNFTs
*
* @dev Role ROLE_BURNER allows burning iNFTs (calling `burn` function)
*/
bytes32 public constant ROLE_BURNER = keccak256("ROLE_BURNER");
/**
* @dev Each intelligent token, represented by its unique ID, is bound to the target NFT,
* defined by the pair of the target NFT smart contract address and unique token ID
* within the target NFT smart contract
*
* @dev Effectively iNFT is owned by the target NFT owner
*
* @dev Additionally, each token holds an AI Pod and some amount of ALI tokens bound to it
*
* @dev `IntelliBinding` keeps all the binding information, including target NFT coordinates,
* bound AI Pod ID, and amount of ALI ERC20 tokens bound to the iNFT
*/
struct IntelliBinding {
// Note: structure members are reordered to fit into less memory slots, see EVM memory layout
// ----- SLOT.1 (256/256)
/**
* @dev Personality prompt is a hash of the data used to feed GPT-3 algorithm
*/
uint256 personalityPrompt;
// ----- SLOT.2 (160/256)
/**
* @dev Address of the target NFT deployed smart contract,
* this is a contract a particular iNFT is bound to
*/
address targetContract;
// ----- SLOT.3 (256/256)
/**
* @dev Target NFT ID within the target NFT smart contract,
* effectively target NFT ID and contract address define the owner of an iNFT
*/
uint256 targetId;
// ----- SLOT.4 (160/256)
/**
* @dev AI Pod ID bound to (owned by) the iNFT
*
* @dev Similar to target NFT, specific AI Pod is also defined by pair of AI Pod smart contract address
* and AI Pod ID; the first one, however, is defined globally and stored in `podContract` constant.
*/
uint64 podId;
/**
* @dev Amount of an ALI ERC20 tokens bound to (owned by) the iNFTs
*
* @dev ALI ERC20 smart contract address is defined globally as `aliContract` constant
*/
uint96 aliValue;
}
/**
* @notice iNFT binding storage, stores binding information for each existing iNFT
* @dev Maps iNFT ID to its binding data, which includes underlying NFT data
*/
mapping (uint256 => IntelliBinding) public bindings;
/**
* @notice Reverse iNFT binding allows to find iNFT bound to a particular NFT
* @dev Maps target NFT (smart contract address and unique token ID) to the linked iNFT:
* NFT Contract => NFT ID => iNFT ID
*/
mapping (address => mapping(uint256 => uint256)) reverseBinding;
/**
* @notice Total amount (maximum value estimate) of iNFT in existence.
* This value can be higher than number of effectively accessible iNFTs
* since when underlying NFT gets burned this value doesn't get updated.
*/
uint256 public override totalSupply;
/**
* @notice Each iNFT holds an AI Pod which is tracked by the AI Pod NFT smart contract defined here
*/
address public podContract;
/**
* @notice Each iNFT holds some ALI tokens, which are tracked by the ALI token ERC20 smart contract defined here
*/
address public aliContract;
/**
* @dev Fired in mint() when new iNFT is created
*
* @param by an address which executed the mint function
* @param owner current owner of the NFT
* @param recordId ID of the iNFT to mint (create, bind)
* @param payer and address which funds the creation (supplies AI Pod and ALI tokens)
* @param podId ID of the AI Pod to bind (transfer) to newly created iNFT
* @param aliValue amount of ALI tokens to bind (transfer) to newly created iNFT
* @param targetContract target NFT smart contract
* @param targetId target NFT ID (where this iNFT binds to and belongs to)
* @param personalityPrompt personality prompt for the minted iNFT
*/
event Minted(
address indexed by,
address owner,
uint64 recordId,
address payer,
uint64 podId,
uint96 aliValue,
address targetContract,
uint256 targetId,
uint256 personalityPrompt
);
/**
* @dev Fired in burn() when an existing iNFT gets destroyed
*
* @param by an address which executed the burn function
* @param recordId ID of the iNFT to burn (destroy, unbind)
* @param recipient and address which receives unlocked AI Pod and ALI tokens (NFT owner)
* @param podId ID of the AI Pod to unbind (transfer) from the destroyed iNFT
* @param aliValue amount of ALI tokens to unbind (transfer) from the destroyed iNFT
* @param aliFee service fee in ALI tokens withheld by burn executor
* @param targetContract target NFT smart contract
* @param targetId target NFT ID (where this iNFT was bound to and belonged to)
* @param personalityPrompt personality prompt for that iNFT
*/
event Burnt(
address indexed by,
uint64 recordId,
address recipient,
uint64 podId,
uint96 aliValue,
uint96 aliFee,
address targetContract,
uint256 targetId,
uint256 personalityPrompt
);
/**
* @dev Fired in setPodContract()
*
* @param by an address which set the `podContract`
* @param podContract AI Pod contract address set
*/
event PodContractSet(address indexed by, address podContract);
/**
* @dev Fired in setAliContract()
*
* @param by an address which set the `aliContract`
* @param aliContract ALI token contract address set
*/
event AliContractSet(address indexed by, address aliContract);
/**
* @dev Creates/deploys an iNFT instance not bound to AI Pod / ALI token instances
*/
constructor() {
// setup admin role for smart contract deployer initially
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
}
/**
* @dev Binds an iNFT instance to already deployed AI Pod instance
*
* @param _pod address of the deployed AI Pod instance to bind iNFT to
*/
function setPodContract(address _pod) public {
// verify sender has permission to access this function
require(isSenderInRole(ROLE_DEPLOYER), "access denied");
// verify the input is set
require(_pod != address(0), "AI Pod addr is not set");
// verify _pod is valid ERC721
require(IERC165(_pod).supportsInterface(type(IERC721).interfaceId), "AI Pod addr is not ERC721");
// setup smart contract internal state
podContract = _pod;
// emit an event
emit PodContractSet(_msgSender(), _pod);
}
/**
* @dev Binds an iNFT instance to already deployed ALI Token instance
*
* @param _ali address of the deployed ALI Token instance to bind iNFT to
*/
function setAliContract(address _ali) public {
// verify sender has permission to access this function
require(isSenderInRole(ROLE_DEPLOYER), "access denied");
// verify the input is set
require(_ali != address(0), "ALI Token addr is not set");
// verify _ali is valid ERC20
require(IERC165(_ali).supportsInterface(type(IERC20).interfaceId), "ALI Token addr is not ERC20");
// setup smart contract internal state
aliContract = _ali;
// emit an event
emit AliContractSet(_msgSender(), _ali);
}
/**
* @inheritdoc IERC165
*/
function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
// reconstruct from current interface and super interface
return interfaceId == type(IIntelligentNFTv1).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @notice Verifies if given iNFT exists
*
* @param recordId iNFT ID to verify existence of
* @return true if iNFT exists, false otherwise
*/
function exists(uint256 recordId) public view override returns (bool) {
// verify if biding exists for that tokenId and return the result
return bindings[recordId].targetContract != address(0);
}
/**
* @notice Returns an owner of the given iNFT.
* By definition iNFT owner is an owner of the target NFT
*
* @param recordId iNFT ID to query ownership information for
* @return address of the given iNFT owner
*/
function ownerOf(uint256 recordId) public view override returns (address) {
// read the token binding
IntelliBinding memory binding = bindings[recordId];
// verify the binding exists and throw standard Zeppelin message if not
require(binding.targetContract != address(0), "iNFT doesn't exist");
// delegate `ownerOf` call to the target NFT smart contract
return IERC721(binding.targetContract).ownerOf(binding.targetId);
}
/**
* @dev Restricted access function which creates an iNFT, binding it to the specified
* NFT, locking the AI Pod specified, and funded with the amount of ALI specified
*
* @dev Transfers AI Pod defined by its ID into iNFT smart contract for locking;
* linking funder must authorize the transfer operation before the mint is called
* @dev Transfers specified amount of ALI token into iNFT smart contract for locking;
* funder must authorize the transfer operation before the mint is called
* @dev The NFT to be linked to doesn't required to belong to the funder, but it must exist
*
* @dev Throws if target NFT doesn't exist
*
* @dev This is a restricted function which is accessed by iNFT Linker
*
* @param recordId ID of the iNFT to mint (create, bind)
* @param funder and address which funds the creation (supplies AI Pod and ALI tokens)
* @param personalityPrompt personality prompt for that iNFT
* @param podId ID of the AI Pod to bind (transfer) to newly created iNFT
* @param aliValue amount of ALI tokens to bind (transfer) to newly created iNFT
* @param targetContract target NFT smart contract
* @param targetId target NFT ID (where this iNFT binds to and belongs to)
*/
function mint(
uint64 recordId,
address funder,
uint256 personalityPrompt,
uint64 podId,
uint96 aliValue,
address targetContract,
uint256 targetId
) public {
// verify the access permission
require(isSenderInRole(ROLE_MINTER), "access denied");
// verify this token ID is not yet bound
require(!exists(recordId), "iNFT already exists");
// verify the NFT is not yet bound
require(reverseBinding[targetContract][targetId] == 0, "target NFT already linked");
// transfer the AI Pod from the specified address `_from`
// using unsafe transfer to avoid unnecessary `onERC721Received` triggering
// Note: we explicitly request AI Pod transfer from the linking funder to be safe
// from the scenarios of potential misuse of AI Pods
IERC721(podContract).transferFrom(funder, address(this), podId);
// transfer the ALI tokens from the specified address `_from`
// using unsafe transfer to avoid unnecessary callback triggering
if(aliValue > 0) {
// note: Zeppelin based AliERC20v1 transfer implementation fails on any error
IERC20(aliContract).transferFrom(funder, address(this), aliValue);
}
// retrieve NFT owner and verify if target NFT exists
address owner = IERC721(targetContract).ownerOf(targetId);
// Note: we do not require funder to be NFT owner,
// if required this constraint should be added by the caller (iNFT Linker)
require(owner != address(0), "target NFT doesn't exist");
// bind AI Pod transferred and ALI ERC20 value transferred to an NFT specified
bindings[recordId] = IntelliBinding({
personalityPrompt: personalityPrompt,
targetContract: targetContract,
targetId: targetId,
podId: podId,
aliValue: aliValue
});
// fill in the reverse binding
reverseBinding[targetContract][targetId] = recordId;
// increase total supply counter
totalSupply++;
// emit an event
emit Minted(_msgSender(), owner, recordId, funder, podId, aliValue, targetContract, targetId, personalityPrompt);
}
/**
* @dev Restricted access function which destroys an iNFT, unbinding it from the
* linked NFT, releasing an AI Pod, and ALI tokens locked in the iNFT
*
* @dev Transfers an AI Pod locked in iNFT to its owner via ERC721.safeTransferFrom;
* owner must be an EOA or implement IERC721Receiver.onERC721Received properly
* @dev Transfers ALI tokens locked in iNFT to its owner and a fee specified to
* transaction executor
* @dev Since iNFT owner is determined as underlying NFT owner, this underlying NFT must
* exist and its ownerOf function must not throw and must return non-zero owner address
* for the underlying NFT ID
*
* @dev Doesn't verify if it's safe to send ALI tokens to the NFT owner, this check
* must be handled by the transaction executor
*
* @dev This is a restricted function which is accessed by iNFT Linker
*
* @param recordId ID of the iNFT to burn (destroy, unbind)
* @param aliFee service fee in ALI tokens to be withheld
*/
function burn(uint64 recordId, uint96 aliFee) public {
// verify the access permission
require(isSenderInRole(ROLE_BURNER), "access denied");
// decrease total supply counter
totalSupply--;
// read the token binding
IntelliBinding memory binding = bindings[recordId];
// verify binding exists
require(binding.targetContract != address(0), "not bound");
// destroy binding first to protect from any reentrancy possibility
delete bindings[recordId];
// free the reverse binding
delete reverseBinding[binding.targetContract][binding.targetId];
// make sure fee doesn't exceed what is bound to iNFT
require(aliFee <= binding.aliValue);
// send the fee to transaction sender
if(aliFee > 0) {
// note: Zeppelin based AliERC20v1 transfer implementation fails on any error
require(IERC20(aliContract).transfer(_msgSender(), aliFee));
}
// determine an owner of the underlying NFT
address owner = IERC721(binding.targetContract).ownerOf(binding.targetId);
// verify that owner address is set (not a zero address)
require(owner != address(0), "no such NFT");
// transfer the AI Pod to the NFT owner
// using safe transfer since we don't know if owner address can accept the AI Pod right now
IERC721(podContract).safeTransferFrom(address(this), owner, binding.podId);
// transfer the ALI tokens to the NFT owner
if(binding.aliValue > aliFee) {
// note: Zeppelin based AliERC20v1 transfer implementation fails on any error
IERC20(aliContract).transfer(owner, binding.aliValue - aliFee);
}
// emit an event
emit Burnt(_msgSender(), recordId, owner, binding.podId, binding.aliValue, aliFee, binding.targetContract, binding.targetId, binding.personalityPrompt);
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
/**
* @title Access Control List Extension Interface
*
* @notice External interface of AccessExtension declared to support ERC165 detection.
* See Access Control List Extension documentation below.
*
* @author Basil Gorin
*/
interface IAccessExtension is IAccessControl {
function removeFeature(bytes32 feature) external;
function addFeature(bytes32 feature) external;
function isFeatureEnabled(bytes32 feature) external view returns(bool);
}
/**
* @title Access Control List Extension
*
* @notice Access control smart contract provides an API to check
* if specific operation is permitted globally and/or
* if particular user has a permission to execute it.
*
* @notice It deals with two main entities: features and roles.
*
* @notice Features are designed to be used to enable/disable specific
* functions (public functions) of the smart contract for everyone.
* @notice User roles are designed to restrict access to specific
* functions (restricted functions) of the smart contract to some users.
*
* @notice Terms "role", "permissions" and "set of permissions" have equal meaning
* in the documentation text and may be used interchangeably.
* @notice Terms "permission", "single permission" implies only one permission set.
*
* @dev OpenZeppelin AccessControl based implementation. Features are stored as
* "self"-roles: feature is a role assigned to the smart contract itself
*
* @dev Automatically assigns the deployer an admin permission
*
* @dev This smart contract is designed to be inherited by other
* smart contracts which require access control management capabilities.
*
* @author Basil Gorin
*/
contract AccessExtension is IAccessExtension, AccessControl {
constructor() {
// setup admin role for smart contract deployer initially
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
}
/**
* @inheritdoc IERC165
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
// reconstruct from current interface and super interface
return interfaceId == type(IAccessExtension).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @notice Removes the feature from the set of the globally enabled features,
* taking into account sender's permissions
*
* @dev Requires transaction sender to have a permission to set the feature requested
*
* @param feature a feature to disable
*/
function removeFeature(bytes32 feature) public override {
// delegate to Zeppelin's `revokeRole`
revokeRole(feature, address(this));
}
/**
* @notice Adds the feature to the set of the globally enabled features,
* taking into account sender's permissions
*
* @dev Requires transaction sender to have a permission to set the feature requested
*
* @param feature a feature to enable
*/
function addFeature(bytes32 feature) public override {
// delegate to Zeppelin's `grantRole`
grantRole(feature, address(this));
}
/**
* @notice Checks if requested feature is enabled globally on the contract
*
* @param feature the feature to check
* @return true if the feature requested is enabled, false otherwise
*/
function isFeatureEnabled(bytes32 feature) public override view returns(bool) {
// delegate to Zeppelin's `hasRole`
return hasRole(feature, address(this));
}
/**
* @notice Checks if transaction sender `msg.sender` has the role required
*
* @param role the role to check against
* @return true if sender has the role required, false otherwise
*/
function isSenderInRole(bytes32 role) public view returns(bool) {
// delegate call to `isOperatorInRole`, passing transaction sender
return hasRole(role, _msgSender());
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControl {
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping (address => bool) members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId
|| super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/
*/
function _checkRole(bytes32 role, address account) internal view {
if(!hasRole(role, account)) {
revert(string(abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32)
)));
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = alphabet[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
| * @notice Checks if transaction sender `msg.sender` has the role required @param role the role to check against @return true if sender has the role required, false otherwise/ delegate call to `isOperatorInRole`, passing transaction sender | function isSenderInRole(bytes32 role) public view returns(bool) {
return hasRole(role, _msgSender());
}
| 116,687 | [
1,
4081,
309,
2492,
5793,
1375,
3576,
18,
15330,
68,
711,
326,
2478,
1931,
225,
2478,
326,
2478,
358,
866,
5314,
327,
638,
309,
5793,
711,
326,
2478,
1931,
16,
629,
3541,
19,
7152,
745,
358,
1375,
291,
5592,
382,
2996,
9191,
9588,
2492,
5793,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
202,
915,
11604,
2345,
382,
2996,
12,
3890,
1578,
2478,
13,
1071,
1476,
1135,
12,
6430,
13,
288,
203,
202,
202,
2463,
28335,
12,
4615,
16,
389,
3576,
12021,
10663,
203,
202,
97,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
//Address: 0xfbb66c9c216df990898c4127958e740b4ac6aa83
//Contract name: FarmCoinSale
//Balance: 0 Ether
//Verification Date: 1/16/2018
//Transacion Count: 1
// CODE STARTS HERE
pragma solidity ^0.4.16;
contract FarmCoin {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
function mintToken(address to, uint256 value) returns (uint256);
function changeTransfer(bool allowed);
}
contract FarmCoinSale {
uint256 public maxMintable;
uint256 public totalMinted;
uint256 public decimals = 18;
uint256 rate;
uint public endBlock;
uint public startBlock;
uint public exchangeRate= rate;
uint public startTime;
bool public isFunding;
FarmCoin public Token;
address public ETHWallet;
uint256 public heldTotal;
bool private configSet;
address public creator;
mapping (address => uint256) public heldTokens;
mapping (address => uint) public heldTimeline;
event Contribution(address from, uint256 amount);
event ReleaseTokens(address from, uint256 amount);
function FarmCoinSale() {
startBlock = block.number;
maxMintable = 4000000000000000000000000; // 3 million max sellable (18 decimals)
ETHWallet = 0x3b444fC8c2C45DCa5e6610E49dC54423c5Dcd86E;
isFunding = true;
creator = msg.sender;
createHeldCoins();
startTime = 1517461200000;
exchangeRate= rate;
}
// start and end dates where crowdsale is allowed (both inclusive)
uint256 constant public START = 1517461200000; // +new Date(2018, 2, 1) / 1000
uint256 constant public END = 1522555200000; // +new Date(2018, 4, 1) / 1000
// @return the rate in FARM per 1 ETH according to the time of the tx and the FARM pricing program.
// @Override
function getRate() constant returns (uint256 rate) {
if (now < START) return rate = 840; // presale, 40% bonus
else if (now <= START + 6 days) return rate = 810; // day 1 to 6, 35% bonus
else if (now <= START + 13 days) return rate = 780; // day 7 to 13, 30% bonus
else if (now <= START + 20 days) return rate = 750; // day 14 to 20, 25% bonus
else if (now <= START + 28 days) return rate = 720; // day 21 to 28, 20% bonus
return rate = 600; // no bonus
}
// setup function to be ran only 1 time
// setup token address
// setup end Block number
function setup(address TOKEN, uint endBlockTime) {
require(!configSet);
Token = FarmCoin(TOKEN);
endBlock = endBlockTime;
configSet = true;
}
function closeSale() external {
require(msg.sender==creator);
isFunding = false;
}
// CONTRIBUTE FUNCTION
// converts ETH to TOKEN and sends new TOKEN to the sender
function contribute() external payable {
require(msg.value>0);
require(isFunding);
require(block.number <= endBlock);
uint256 amount = msg.value * exchangeRate;
uint256 total = totalMinted + amount;
require(total<=maxMintable);
totalMinted += total;
ETHWallet.transfer(msg.value);
Token.mintToken(msg.sender, amount);
Contribution(msg.sender, amount);
}
// update the ETH/COIN rate
function updateRate(uint256 rate) external {
require(msg.sender==creator);
require(isFunding);
exchangeRate = rate;
}
// change creator address
function changeCreator(address _creator) external {
require(msg.sender==creator);
creator = _creator;
}
// change transfer status for FarmCoin token
function changeTransferStats(bool _allowed) external {
require(msg.sender==creator);
Token.changeTransfer(_allowed);
}
// internal function that allocates a specific amount of ATYX at a specific block number.
// only ran 1 time on initialization
function createHeldCoins() internal {
// TOTAL SUPPLY = 5,000,000
createHoldToken(msg.sender, 1000);
createHoldToken(0xd9710D829fa7c36E025011b801664009E4e7c69D, 100000000000000000000000);
createHoldToken(0xd9710D829fa7c36E025011b801664009E4e7c69D, 100000000000000000000000);
}
// function to create held tokens for developer
function createHoldToken(address _to, uint256 amount) internal {
heldTokens[_to] = amount;
heldTimeline[_to] = block.number + 0;
heldTotal += amount;
totalMinted += heldTotal;
}
// function to release held tokens for developers
function releaseHeldCoins() external {
uint256 held = heldTokens[msg.sender];
uint heldBlock = heldTimeline[msg.sender];
require(!isFunding);
require(held >= 0);
require(block.number >= heldBlock);
heldTokens[msg.sender] = 0;
heldTimeline[msg.sender] = 0;
Token.mintToken(msg.sender, held);
ReleaseTokens(msg.sender, held);
}
}
| @return the rate in FARM per 1 ETH according to the time of the tx and the FARM pricing program. @Override | function getRate() constant returns (uint256 rate) {
}
| 15,795,540 | [
1,
2463,
326,
4993,
316,
478,
26120,
1534,
404,
512,
2455,
4888,
358,
326,
813,
434,
326,
2229,
471,
326,
478,
26120,
31765,
5402,
18,
632,
6618,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
445,
4170,
340,
1435,
5381,
1135,
261,
11890,
5034,
4993,
13,
288,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/8453/0x15DC38eC9F17a828f8Bd3c0125536f90575d1aB7/sources/BaseAiDao.sol | 0.25% of total supply
| uint256 public maxWalletAmount = _totalSupply * 25 / 10000; | 11,553,386 | [
1,
20,
18,
2947,
9,
434,
2078,
14467,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
2254,
5034,
1071,
943,
16936,
6275,
273,
389,
4963,
3088,
1283,
380,
6969,
342,
12619,
31,
282,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./EController.sol";
import "./IAssetToken.sol";
import "./AssetTokenBase.sol";
contract AssetTokenEL is IAssetTokenERC20, AssetTokenBase {
using SafeMath for uint256;
using AssetTokenLibrary for SpentLocalVars;
using AssetTokenLibrary for AmountLocalVars;
IERC20 private _el;
/// @notice Emitted when an user claimed reward
event RewardClaimed(address account, uint256 reward);
constructor(
IERC20 el_,
IEController eController_,
uint256 amount_,
uint256 price_,
uint256 rewardPerBlock_,
uint256 payment_,
uint256 latitude_,
uint256 longitude_,
uint256 assetPrice_,
uint256 interestRate_,
string memory name_,
string memory symbol_,
uint8 decimals_
)
AssetTokenBase(
eController_,
amount_,
price_,
rewardPerBlock_,
payment_,
latitude_,
longitude_,
assetPrice_,
interestRate_,
name_,
symbol_,
decimals_
)
{
_el = el_;
}
/**
* @dev purchase asset token with el.
*
* This can be used to purchase asset token with Elysia Token (EL).
*
* Requirements:
* - `spent` msg.sender should have more spent.
* - `spent` this contract should have more asset tokens amount calculated with spent.
*/
function purchase(uint256 spent)
external
override
whenNotPaused
{
AmountLocalVars memory vars =
AmountLocalVars({
spent: spent,
currencyPrice: eController.getPrice(payment),
assetTokenPrice: price
});
uint256 amount = vars.getAmount();
_checkBalance(msg.sender, spent, address(this), amount);
require(
_el.transferFrom(
msg.sender,
address(this),
spent
),
"EL : transferFrom failed"
);
_transfer(address(this), msg.sender, amount);
}
/**
* @dev refund asset token.
*
* This can be used to refund asset token with Elysia Token (EL).
*
* Requirements:
* - `amount` msg.sender should have more asset token than the amount.
* - `amount` this contract should have more el than elAmount converted from the amount.
*/
function refund(uint256 amount)
external
override
whenNotPaused
{
SpentLocalVars memory vars =
SpentLocalVars({
amount: amount,
currencyPrice: eController.getPrice(payment),
assetTokenPrice: price
});
uint256 spent = vars.getSpent();
_checkBalance(address(this), spent, msg.sender, amount);
require(
_el.transfer(msg.sender, spent),
"EL : transfer failed"
);
_transfer(msg.sender, address(this), amount);
}
/**
* @dev Claim account reward.
*
* This can be used to claim account accumulated rewrard with Elysia Token (EL).
*
* Emits a {RewardClaimed} event.
*/
function claimReward()
external
override
whenNotPaused
{
uint256 reward =
getReward(msg.sender).mul(1e18).div(eController.getPrice(payment));
require(
reward <= _el.balanceOf(address(this)),
"AssetToken: Insufficient seller balance."
);
_el.transfer(msg.sender, reward);
_clearReward(msg.sender);
emit RewardClaimed(msg.sender, reward);
}
/**
* @dev check if buyer and seller have sufficient balance.
*
* This can be used to check balance of buyer and seller before swap.
*
* Requirements:
* - `spent` should be positive.
* - `spent` buyer should have spent token value than the spent.
* - `amount` should be positive.
* - `amount` seller should have more asset token balance than amount.
*/
function _checkBalance(
address buyer,
uint256 spent,
address seller,
uint256 amount
) internal view {
require(
spent > 0 && amount > 0,
"AssetToken: Wrong spent or amount."
);
require(
_el.balanceOf(buyer) >= spent,
"AssetToken: Insufficient buyer el balance."
);
require(
balanceOf(seller) >= amount,
"AssetToken: Insufficient seller balance."
);
}
/**
* @dev Withdraw all El from this contract to admin
*/
function withdrawToAdmin() public onlyAdmin(msg.sender) {
_el.transfer(msg.sender, _el.balanceOf(address(this)));
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./IEPriceOracle.sol";
import "./EPriceOracleEth.sol";
import "./IAssetToken.sol";
interface IEController {
function getPrice(uint payment) external view returns (uint);
function isAdmin(address account) external view returns (bool);
}
/**
* @title Elysia's Asset Control layer
* @notice Controll admin
* @author Elysia
*/
contract EController is IEController, AccessControl {
// AssetToken list
IAssetTokenBase[] public assetTokenList;
// 0: el, 1: eth, 2: wBTC ...
mapping(uint256 => IEPriceOracle) public ePriceOracle;
/// @notice Emitted when new priceOracle is set
event NewPriceOracle(address ePriceOracle);
/// @notice Emitted when new assetToken is set
event NewAssetToken(address assetToken);
constructor() {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(DEFAULT_ADMIN_ROLE, address(this));
}
/*** Oracle View functions ***/
function getPrice(uint payment) external view override returns (uint256) {
IEPriceOracle oracle = ePriceOracle[payment];
return oracle.getPrice();
}
/*** Admin Functions on Setup ***/
/**
* @notice Set EPriceoracle in each payment
* @param ePriceOracle_ The address of the ePriceOracle to be enabled
* @param payment The payment of price feed
*/
function setEPriceOracle(IEPriceOracle ePriceOracle_, uint256 payment)
external
onlyAdmin
{
ePriceOracle[payment] = ePriceOracle_;
emit NewPriceOracle(address(ePriceOracle_));
}
/**
* @notice Add assets to be included in eController
* @param assetTokens The list of addresses of the assetTokens to be enabled
*/
function setAssetTokens(IAssetTokenBase[] memory assetTokens)
external
onlyAdmin
{
uint256 len = assetTokens.length;
for (uint256 i = 0; i < len; i++) {
assetTokenList.push(assetTokens[i]);
emit NewAssetToken(address(assetTokens[i]));
}
}
function setAdmin(address account)
external
onlyAdmin
{
_setupRole(DEFAULT_ADMIN_ROLE, account);
renounceRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
function pauseAssetTokens(IAssetTokenBase[] memory assetTokens)
public
onlyAdmin
{
uint256 len = assetTokens.length;
for (uint256 i = 0; i < len; i++) {
assetTokens[i].pause();
}
}
function unpauseAssetTokens(IAssetTokenBase[] memory assetTokens)
public
onlyAdmin
{
uint256 len = assetTokens.length;
for (uint256 i = 0; i < len; i++) {
assetTokens[i].unpause();
}
}
/*** Access Controllers ***/
/// @dev Restricted to members of the admin role.
modifier onlyAdmin() {
require(_isAdmin(msg.sender), "Restricted to admin.");
_;
}
/// @dev Return `true` if the account belongs to the admin role.
function isAdmin(address account)
external
view
override
returns (bool) {
return _isAdmin(account);
}
function _isAdmin(address account) internal view returns (bool) {
return hasRole(DEFAULT_ADMIN_ROLE, account);
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
interface IAssetTokenBase {
function setRewardPerBlock(uint256 rewardPerBlock_) external returns (bool);
function pause() external;
function unpause() external;
function setEController(address eController) external;
function getLatitude() external view returns (uint256);
function getLongitude() external view returns (uint256);
function getAssetPrice() external view returns (uint256);
function getInterestRate() external view returns (uint256);
function getPrice() external view returns (uint256);
function getPayment() external view returns (uint256);
}
interface IAssetTokenERC20 {
function purchase(uint256 spent) external;
function refund(uint256 amount) external;
function claimReward() external;
}
interface IAssetTokenEth {
function purchase() external payable;
function refund(uint256 amount) external;
function claimReward() external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "./IAssetToken.sol";
import "./IEPriceOracle.sol";
import "./EController.sol";
import "./Library.sol";
contract AssetTokenBase is IAssetTokenBase, ERC20, Pausable {
using SafeMath for uint256;
using AssetTokenLibrary for RewardLocalVars;
IEController public eController;
uint256 public latitude;
uint256 public longitude;
uint256 public assetPrice;
uint256 public interestRate;
// USD per Elysia Asset Token
// decimals: 18
uint256 public price;
// monthlyRent$/(secondsPerMonth*averageBlockPerSecond)
// Decimals: 18
uint256 public rewardPerBlock;
// 0: el, 1: eth, 2: wBTC ...
uint256 public payment;
// Account rewards (USD)
// Decimals: 18
mapping(address => uint256) private _rewards;
// Account block numbers
mapping(address => uint256) private _blockNumbers;
/// @notice Emitted when rewards per block is changed
event NewRewardPerBlock(uint256 newRewardPerBlock);
/// @notice Emitted when eController is changed
event NewController(address newController);
constructor(
IEController eController_,
uint256 amount_,
uint256 price_,
uint256 rewardPerBlock_,
uint256 payment_,
uint256 latitude_,
uint256 longitude_,
uint256 assetPrice_,
uint256 interestRate_,
string memory name_,
string memory symbol_,
uint8 decimals_
) ERC20(name_, symbol_) {
eController = eController_;
price = price_;
rewardPerBlock = rewardPerBlock_;
payment = payment_;
latitude = latitude_;
longitude = longitude_;
assetPrice = assetPrice_;
interestRate = interestRate_;
_mint(address(this), amount_);
_setupDecimals(decimals_);
}
/*** View functions ***/
function getLatitude() external view override returns (uint256) {
return latitude;
}
function getLongitude() external view override returns (uint256) {
return longitude;
}
function getAssetPrice() external view override returns (uint256) {
return assetPrice;
}
function getInterestRate() external view override returns (uint256) {
return interestRate;
}
function getPrice() external view override returns (uint256) {
return price;
}
function getPayment() external view override returns (uint256) {
return payment;
}
/*** Admin functions ***/
function setEController(address newEController)
external
override
onlyAdmin(msg.sender)
{
eController = IEController(newEController);
emit NewController(address(eController));
}
function setRewardPerBlock(uint256 rewardPerBlock_)
external
override
onlyAdmin(msg.sender)
returns (bool)
{
rewardPerBlock = rewardPerBlock_;
emit NewRewardPerBlock(rewardPerBlock_);
return true;
}
function pause() external override onlyAdmin(msg.sender) {
_pause();
}
function unpause() external override onlyAdmin(msg.sender) {
_unpause();
}
/*** Reward functions ***/
/**
* @notice Get reward
* @param account Addresss
* @return saved reward + new reward
*/
function getReward(address account) public view returns (uint256) {
RewardLocalVars memory vars =
RewardLocalVars({
newReward: 0,
accountReward: _rewards[account],
accountBalance: balanceOf(account),
rewardBlockNumber: _blockNumbers[account],
blockNumber: block.number,
diffBlock: 0,
rewardPerBlock: rewardPerBlock,
totalSupply: totalSupply()
});
return vars.getReward();
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
/* RewardManager */
_saveReward(from);
_saveReward(to);
}
function _saveReward(address account) internal returns (bool) {
if (account == address(this)) {
return true;
}
_rewards[account] = getReward(account);
_blockNumbers[account] = block.number;
return true;
}
function _clearReward(address account) internal returns (bool) {
_rewards[account] = 0;
_blockNumbers[account] = block.number;
return true;
}
/// @dev Restricted to members of the admin role.
modifier onlyAdmin(address account) {
require(eController.isAdmin(account), "Restricted to admin.");
_;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../utils/EnumerableSet.sol";
import "../utils/Address.sol";
import "../GSN/Context.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
interface IEPriceOracle {
function getPrice() external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
import "@openzeppelin/contracts/utils/SafeCast.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./IEPriceOracle.sol";
import "./Library.sol";
/**
* @title Elysia's price feed
* @notice implements chainlink price aggregator
* @author Elysia
*/
contract EPriceOracleEth is IEPriceOracle {
using SafeCast for int256;
using SafeMath for uint256;
address public admin;
/// @notice Emitted when admin is changed
event NewAdmin(address newAdmin);
AggregatorV3Interface internal _priceFeed;
constructor(address priceFeed_) {
_priceFeed = AggregatorV3Interface(priceFeed_);
admin = msg.sender;
}
function getPrice() external view override returns (uint256) {
return _getEthPrice();
}
function _getEthPrice() internal view returns (uint256) {
(
uint80 roundID,
int256 price,
uint256 startedAt,
uint256 timeStamp,
uint80 answeredInRound
) = _priceFeed.latestRoundData();
return price.toUint256().mul(1e10);
}
function setAdmin(address account) external {
require(msg.sender == admin, "Restricted to admin.");
admin = account;
emit NewAdmin(account);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
pragma solidity >=0.6.0;
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*
* Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
* all math on `uint256` and `int256` and then downcasting.
*/
library SafeCast {
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
return uint128(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
return uint64(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
return uint32(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits.
*/
function toUint8(uint256 value) internal pure returns (uint8) {
require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v3.1._
*/
function toInt128(int256 value) internal pure returns (int128) {
require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits");
return int128(value);
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v3.1._
*/
function toInt64(int256 value) internal pure returns (int64) {
require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits");
return int64(value);
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v3.1._
*/
function toInt32(int256 value) internal pure returns (int32) {
require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits");
return int32(value);
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v3.1._
*/
function toInt16(int256 value) internal pure returns (int16) {
require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits");
return int16(value);
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits.
*
* _Available since v3.1._
*/
function toInt8(int256 value) internal pure returns (int8) {
require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits");
return int8(value);
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
require(value < 2**255, "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
import "@openzeppelin/contracts/math/SafeMath.sol";
struct RewardLocalVars {
uint256 newReward;
uint256 accountReward;
uint256 accountBalance;
uint256 rewardBlockNumber;
uint256 blockNumber;
uint256 diffBlock;
uint256 rewardPerBlock;
uint256 totalSupply;
}
struct SpentLocalVars {
uint amount;
uint256 currencyPrice;
uint256 assetTokenPrice;
}
struct AmountLocalVars {
uint256 spent;
uint256 currencyPrice;
uint256 assetTokenPrice;
}
library AssetTokenLibrary {
using SafeMath for uint256;
function getReward(RewardLocalVars memory self)
internal
pure
returns (uint256)
{
if (
self.rewardBlockNumber != 0 &&
self.blockNumber > self.rewardBlockNumber
) {
self.diffBlock = self.blockNumber.sub(self.rewardBlockNumber);
self.newReward = self
.accountBalance
.mul(self.diffBlock)
.mul(self.rewardPerBlock)
.div(self.totalSupply);
}
return self.accountReward.add(self.newReward);
}
function getSpent(SpentLocalVars memory self)
internal
pure
returns (uint)
{
return self.amount.mul(self.assetTokenPrice).div(self.currencyPrice);
}
function getAmount(AmountLocalVars memory self)
internal
pure
returns (uint)
{
return self.spent.mul(self.currencyPrice).div(self.assetTokenPrice);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../../GSN/Context.sol";
import "./IERC20.sol";
import "../../math/SafeMath.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../GSN/Context.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor () internal {
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
} | * @dev check if buyer and seller have sufficient balance. This can be used to check balance of buyer and seller before swap. Requirements: - `spent` should be positive. - `spent` buyer should have spent token value than the spent. - `amount` should be positive. - `amount` seller should have more asset token balance than amount./ | function _checkBalance(
address buyer,
uint256 spent,
address seller,
uint256 amount
) internal view {
require(
spent > 0 && amount > 0,
"AssetToken: Wrong spent or amount."
);
require(
_el.balanceOf(buyer) >= spent,
"AssetToken: Insufficient buyer el balance."
);
require(
balanceOf(seller) >= amount,
"AssetToken: Insufficient seller balance."
);
}
| 5,770,437 | [
1,
1893,
309,
27037,
471,
29804,
1240,
18662,
11013,
18,
1220,
848,
506,
1399,
358,
866,
11013,
434,
27037,
471,
29804,
1865,
7720,
18,
29076,
30,
300,
1375,
20693,
68,
1410,
506,
6895,
18,
300,
1375,
20693,
68,
27037,
1410,
1240,
26515,
1147,
460,
2353,
326,
26515,
18,
300,
1375,
8949,
68,
1410,
506,
6895,
18,
300,
1375,
8949,
68,
29804,
1410,
1240,
1898,
3310,
1147,
11013,
2353,
3844,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
389,
1893,
13937,
12,
203,
3639,
1758,
27037,
16,
203,
3639,
2254,
5034,
26515,
16,
203,
3639,
1758,
29804,
16,
203,
3639,
2254,
5034,
3844,
203,
565,
262,
2713,
1476,
288,
203,
3639,
2583,
12,
203,
5411,
26515,
405,
374,
597,
3844,
405,
374,
16,
203,
5411,
315,
6672,
1345,
30,
24668,
26515,
578,
3844,
1199,
203,
3639,
11272,
203,
203,
3639,
2583,
12,
203,
5411,
389,
292,
18,
12296,
951,
12,
70,
16213,
13,
1545,
26515,
16,
203,
5411,
315,
6672,
1345,
30,
22085,
11339,
27037,
415,
11013,
1199,
203,
3639,
11272,
203,
203,
3639,
2583,
12,
203,
5411,
11013,
951,
12,
1786,
749,
13,
1545,
3844,
16,
203,
5411,
315,
6672,
1345,
30,
22085,
11339,
29804,
11013,
1199,
203,
3639,
11272,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/GSN/Context.sol";
import "./Ownable.sol";
// Drachma is a token used for Governance. It is minted by Plutus, and they cannot be transfered.
contract Drachma is Ownable {
using SafeMath for uint256;
// ** ERC20 variables ** //
mapping (address => uint256) private _balances;
uint256 private _totalSupply;
string private constant _name = "Drachma";
string private constant _symbol = "DRACHMA";
uint8 private constant _decimals = 18;
// ** Governance variables ** //
/// @dev 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 {
uint256 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 => uint256) 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,
uint256 previousBalance,
uint256 newBalance
);
event Minted(
address indexed minter,
address indexed receiver,
uint256 mintAmount
);
event Burned(address indexed burner, uint256 burnAmount);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor () public{
}
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
emit Minted(owner(), _to, _amount);
}
function burn(address _to, uint256 _amount) public onlyOwner{
_burn(_to, _amount);
emit Burned(_to, _amount);
}
/**
* @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,
uint256 nonce,
uint256 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),
"POLIS::delegateBySig: invalid signature"
);
require(
nonce == nonces[signatory]++,
"POLIS::delegateBySig: invalid nonce"
);
require(block.timestamp <= expiry, "POLIS::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
/**
* @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 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, uint256 blockNumber)
external
view
returns (uint256)
{
require(
blockNumber < block.number,
"POLIS::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 POLIs (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 {
uint256 blockNumber = block.number;
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 getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
_moveDelegates(_delegates[from], _delegates[to], amount);
}
// Some ERC20 functions
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
} | @dev A record of each accounts delegate @notice A checkpoint for marking number of votes from a given block | struct Checkpoint {
uint256 fromBlock;
uint256 votes;
}
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
"Delegation(address delegatee,uint256 nonce,uint256 expiry)"
);
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);
address indexed delegate,
uint256 previousBalance,
uint256 newBalance
);
event Minted(
address indexed minter,
address indexed receiver,
uint256 mintAmount
);
event Burned(address indexed burner, uint256 burnAmount);
| 13,081,413 | [
1,
37,
1409,
434,
1517,
9484,
7152,
225,
432,
9776,
364,
24073,
1300,
434,
19588,
628,
279,
864,
1203,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
1958,
25569,
288,
203,
3639,
2254,
5034,
628,
1768,
31,
203,
3639,
2254,
5034,
19588,
31,
203,
565,
289,
203,
203,
203,
203,
3639,
315,
41,
2579,
27,
2138,
3748,
12,
1080,
508,
16,
11890,
5034,
2687,
548,
16,
2867,
3929,
310,
8924,
2225,
203,
565,
11272,
203,
203,
3639,
315,
26945,
12,
2867,
7152,
73,
16,
11890,
5034,
7448,
16,
11890,
5034,
10839,
2225,
203,
565,
11272,
203,
203,
203,
3639,
1758,
8808,
11158,
639,
16,
203,
3639,
1758,
8808,
628,
9586,
16,
203,
3639,
1758,
8808,
358,
9586,
203,
565,
11272,
203,
203,
3639,
1758,
8808,
7152,
16,
203,
3639,
2254,
5034,
2416,
13937,
16,
203,
3639,
2254,
5034,
394,
13937,
203,
565,
11272,
203,
203,
565,
871,
490,
474,
329,
12,
203,
3639,
1758,
8808,
1131,
387,
16,
203,
3639,
1758,
8808,
5971,
16,
203,
3639,
2254,
5034,
312,
474,
6275,
203,
565,
11272,
203,
565,
871,
605,
321,
329,
12,
2867,
8808,
18305,
264,
16,
2254,
5034,
18305,
6275,
1769,
203,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/11155111/0x512cd805947A4aa05E4CBB5508F6C2261f00500A/sources/contracts/nft_minting.sol | podriem enviar-li el nom per al constructor | contract MyNFT is ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
function mintNFT(address recipient, string memory tokenURI)
public
onlyOwner
returns (uint256)
pragma solidity ^0.8.17;
constructor() ERC721("MyNFT", "NFT") {}
{
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(recipient, newItemId);
_setTokenURI(newItemId, tokenURI);
return newItemId;
}
} | 3,535,730 | [
1,
7832,
566,
351,
570,
522,
297,
17,
549,
415,
12457,
1534,
524,
3885,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
8005,
50,
4464,
353,
4232,
39,
27,
5340,
3098,
3245,
16,
14223,
6914,
288,
203,
565,
1450,
9354,
87,
364,
9354,
87,
18,
4789,
31,
203,
565,
9354,
87,
18,
4789,
3238,
389,
2316,
2673,
31,
203,
203,
203,
565,
445,
312,
474,
50,
4464,
12,
2867,
8027,
16,
533,
3778,
1147,
3098,
13,
203,
3639,
1071,
203,
3639,
1338,
5541,
203,
3639,
1135,
261,
11890,
5034,
13,
203,
683,
9454,
18035,
560,
3602,
20,
18,
28,
18,
4033,
31,
203,
202,
12316,
1435,
4232,
39,
27,
5340,
2932,
12062,
50,
4464,
3113,
315,
50,
4464,
7923,
2618,
203,
565,
288,
203,
3639,
389,
2316,
2673,
18,
15016,
5621,
203,
203,
3639,
2254,
5034,
394,
17673,
273,
389,
2316,
2673,
18,
2972,
5621,
203,
3639,
389,
81,
474,
12,
20367,
16,
394,
17673,
1769,
203,
3639,
389,
542,
1345,
3098,
12,
2704,
17673,
16,
1147,
3098,
1769,
203,
203,
3639,
327,
394,
17673,
31,
203,
565,
289,
203,
97,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
/**
*Submitted for verification at Etherscan.io on 2020-08-26
*/
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
pragma solidity ^0.6.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/math/SafeMath.sol
pragma solidity ^0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
pragma solidity ^0.6.2;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
pragma solidity ^0.6.0;
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: @openzeppelin/contracts/utils/EnumerableSet.sol
pragma solidity ^0.6.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// File: @openzeppelin/contracts/GSN/Context.sol
pragma solidity ^0.6.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
pragma solidity ^0.6.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol
pragma solidity ^0.6.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// File: contracts/AntsToken.sol
pragma solidity 0.6.12;
// AntsToken with Governance.
contract AntsToken is ERC20("AntsToken", "ANTS"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
require(totalSupply() < 1e26 , "Totoal supply overflow"); // 1e8 ** decimal
_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), "ANTS::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "ANTS::delegateBySig: invalid nonce");
require(now <= expiry, "ANTS::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, "ANTS::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 ANTSs (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, "ANTS::_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;
}
}
// File: contracts/MasterChef.sol
pragma solidity 0.6.12;
interface IMigratorChef {
// Perform LP token migration from legacy UniswapV2 to AntsSwap.
// Take the current LP token address and return the new LP token address.
// Migrator should have full access to the caller's LP token.
// Return the new LP token address.
//
// XXX Migrator must have allowance access to UniswapV2 LP tokens.
// AntsSwap must mint EXACTLY the same amount of AntsSwap LP tokens or
// else something bad will happen. Traditional UniswapV2 does not
// do that so be careful!
function migrate(IERC20 token) external returns (IERC20);
}
// MasterChef is the master of Ants. He can make Ants and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once SUSHI is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterChef is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
uint256 lockBlock; // lockBlock
uint256 lockedAmount; // lockedAmount
uint256 pending; // pending amount, convert to amount via withdraw
//
// We do some fancy math here. Basically, any point in time, the amount of ANTSs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accAntsPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accAntsPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
bool isSingle; // sigle token mint
uint256 allocPoint; // How many allocation points assigned to this pool. ANTSs to distribute per block.
uint256 lastRewardBlock; // Last block number that ANTSs distribution occurs.
uint256 accAntsPerShare; // Accumulated ANTSs per share, times 1e12. See below.
}
// The ANTS TOKEN!
AntsToken public ants;
// Dev address.
address public devaddr;
// Block number when bonus ANTS period ends.
uint256 public bonusEndBlock;
// Token locked block length
uint256 public halvedBlock;
uint256 public halvedBlockLength = 2_000_000;
// Token locked block length
uint256 public antsLockedBlock;
// ANTS tokens created per block.
uint256 public antsPerBlock;
// Bonus muliplier for early ants makers.
uint256 public constant BONUS_MULTIPLIER = 5;
// The migrator contract. It has a lot of power. Can only be set through governance (owner).
IMigratorChef public migrator;
// Invite user
mapping (address => uint256) public balanceInvite;
mapping (address => address) public userInvite;
mapping (address => bool) public userInviteAble;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when ANTS mining starts.
uint256 public startBlock;
event Invite(address indexed inviter, address indexed invitee);
event InviteReward(address indexed inviter, address indexed invitee, uint256 amount);
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
AntsToken _ants,
address _devaddr,
uint256 _antsPerBlock,
uint256 _startBlock,
uint256 _bonusEndBlock
) public {
ants = _ants;
devaddr = _devaddr;
antsPerBlock = _antsPerBlock;
bonusEndBlock = _bonusEndBlock;
startBlock = _startBlock;
halvedBlock = _startBlock;
antsLockedBlock = 200_000;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken , bool _isSingle, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
isSingle: _isSingle,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accAntsPerShare: 0
}));
}
// Update the given pool's ANTS allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// Set the migrator contract. Can only be called by the owner.
function setMigrator(IMigratorChef _migrator) public onlyOwner {
migrator = _migrator;
}
// Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good.
function migrate(uint256 _pid) public {
require(address(migrator) != address(0), "migrate: no migrator");
PoolInfo storage pool = poolInfo[_pid];
IERC20 lpToken = pool.lpToken;
uint256 bal = lpToken.balanceOf(address(this));
lpToken.safeApprove(address(migrator), bal);
IERC20 newLpToken = migrator.migrate(lpToken);
require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
pool.lpToken = newLpToken;
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
if (_to <= bonusEndBlock) {
return _to.sub(_from).mul(BONUS_MULTIPLIER);
} else if (_from >= bonusEndBlock) {
return _to.sub(_from);
} else {
return bonusEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(
_to.sub(bonusEndBlock)
);
}
}
// View function to see pending ANTSs on frontend.
function pendingAnts(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accAntsPerShare = pool.accAntsPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 antsReward = multiplier.mul(antsPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accAntsPerShare = accAntsPerShare.add(antsReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accAntsPerShare).div(1e12).sub(user.rewardDebt);
}
// View function to see pending ANTSs on frontend.
function totalPendingAnts(uint256 _pid, address _user) external view returns (uint256 , uint256 ) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accAntsPerShare = pool.accAntsPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 antsReward = multiplier.mul(antsPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accAntsPerShare = accAntsPerShare.add(antsReward.mul(1e12).div(lpSupply));
}
uint256 pending = user.amount.mul(accAntsPerShare).div(1e12).sub(user.rewardDebt).add(user.pending);
uint256 reward = 0;
if(userInvite[_user] != address(0) && userInvite[_user] != address(this) ) {
reward = pending.mul(1).div(20);
}
return (pending, reward);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 antsReward = multiplier.mul(antsPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
// UserInfo storage dev = userInfo[_pid][devaddr];
// dev.pending = dev.pending.add(antsReward.div(20));
ants.mint(devaddr, antsReward.div(20));
ants.mint(address(this), antsReward);
pool.accAntsPerShare = pool.accAntsPerShare.add(antsReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
if(block.number >= halvedBlockLength.add(halvedBlock)) {
halvedBlock = block.number;
antsPerBlock = antsPerBlock.div(2);
}
}
function updateLockBlock(uint256 _pid, uint256 _amount) internal {
UserInfo storage user = userInfo[_pid][msg.sender];
if(user.lockBlock == 0) {//
user.lockBlock = block.number;
}else {
// (b-a) * amountB/(amountA + amountbB)
user.lockBlock = block.number.sub(user.lockBlock).mul(_amount).div(user.amount.add(_amount)).add(user.lockBlock);
}
}
function setInviter(address _inviter) public {
require(_inviter != address(0), "Inviter not null");
require(_inviter != msg.sender, "Inviter cannot be self");
require(userInviteAble[_inviter], "Inviter invalid");
userInvite[msg.sender] = _inviter;
}
function depositWithInvite(uint256 _pid, uint256 _amount, address _inviter) public {
if( userInvite[msg.sender] == address(0) ) {
require(_inviter != address(0), "Inviter not null");
require(_inviter != msg.sender, "Inviter cannot be self");
require(userInviteAble[_inviter], "Inviter invalid");
userInvite[msg.sender] = _inviter;
emit Invite(_inviter, msg.sender);
}
deposit(_pid, _amount);
}
// Deposit LP tokens to MasterChef for ANTS allocation.
function deposit(uint256 _pid, uint256 _amount) public {
if(_amount > 0 && !userInviteAble[msg.sender]) {
userInviteAble[msg.sender] = true;
}
if(userInvite[msg.sender] == address(0) ) {
userInvite[msg.sender] = address(this);
}
updateLockBlock(_pid, _amount);
updatePool(_pid);
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accAntsPerShare).div(1e12).sub(user.rewardDebt);
// safeAntsTransfer(msg.sender, pending);
user.pending = user.pending.add(pending);
}
if(pool.isSingle) {
chefSafeTransferFrom(pool.lpToken, address(msg.sender), address(this), _amount);
}else {
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
}
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accAntsPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from MasterChef.
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accAntsPerShare).div(1e12).sub(user.rewardDebt);
user.pending = user.pending.add(pending);
//pending ++
//exec safeAntsTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accAntsPerShare).div(1e12);
if(pool.isSingle) {
chefSafeTransfer(pool.lpToken, address(msg.sender), _amount);
}else {
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
emit Withdraw(msg.sender, _pid, _amount);
}
function withdrawInviteReward() public {
ants.mint(msg.sender, balanceInvite[msg.sender] );
balanceInvite[msg.sender] = 0;
}
function withdrawToken(uint256 _pid) public {
updatePool(_pid);
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint pending = user.amount.mul(pool.accAntsPerShare).div(1e12).sub(user.rewardDebt);
user.pending = pending.add(user.pending);
user.rewardDebt = user.amount.mul(pool.accAntsPerShare).div(1e12);
bool invited = userInvite[msg.sender] != address(0) && userInvite[msg.sender] != address(this);
uint256 availablePending = invited? user.pending.mul(21).div(20) : user.pending;
if(user.lockBlock > 0 && block.number.sub(user.lockBlock) < antsLockedBlock ) {
availablePending = availablePending.mul(block.number.sub(user.lockBlock)).div(antsLockedBlock);
}
if(availablePending > 0 ){
//update lockedNumber
//block.number.sub(user.lockBlock).mul(withdrawAmount).div(availablePending).add(user.lockBlock);
if(invited) {
//mint invitee reward
ants.mint(msg.sender, availablePending.mul(1).div(21));
availablePending = availablePending.mul(20).div(21); // avaliable = avaliable * 1.05
//record inviter reward
address inviter = userInvite[msg.sender];
uint256 reward = availablePending.div(10);
balanceInvite[inviter] = balanceInvite[inviter].add(reward);
emit InviteReward(inviter, msg.sender, reward);
}
safeAntsTransfer(msg.sender, availablePending);
user.pending = user.pending.sub(availablePending);
user.lockBlock = block.number;
}
if(user.amount == 0 && user.pending == 0) {
user.lockBlock = 0;
}
}
function calcuAvalible(uint256 _pid , address _user) external view returns (uint256 ) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accAntsPerShare = pool.accAntsPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 antsReward = multiplier.mul(antsPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accAntsPerShare = accAntsPerShare.add(antsReward.mul(1e12).div(lpSupply));
}
uint256 addPending = user.amount.mul(accAntsPerShare).div(1e12).sub(user.rewardDebt);
uint256 totalPending = user.pending.add(addPending);
bool invited = userInvite[_user] != address(0) && userInvite[_user] != address(this) ;
uint256 pending = invited? totalPending.mul(21).div(20) : totalPending;
if(user.lockBlock > 0 && block.number.sub(user.lockBlock) < antsLockedBlock) {
return pending.mul(block.number.sub(user.lockBlock)).div(antsLockedBlock);
}else {
return pending;
}
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
if(pool.isSingle) {
chefSafeTransfer(pool.lpToken, address(msg.sender), user.amount);
}else {
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
}
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe ants transfer function, just in case if rounding error causes pool to not have enough ANTSs.
function safeAntsTransfer(address _to, uint256 _amount) internal {
uint256 antsBal = ants.balanceOf(address(this));
if (_amount > antsBal) {
ants.transfer(_to, antsBal);
} else {
ants.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
function chefSafeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function chefSafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
} | * @dev Returns the number of values on the set. O(1)./ | function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
| 10,403,577 | [
1,
1356,
326,
1300,
434,
924,
603,
326,
444,
18,
531,
12,
21,
2934,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
3639,
445,
389,
2469,
12,
694,
2502,
444,
13,
3238,
1476,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
444,
6315,
2372,
18,
2469,
31,
203,
3639,
289,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity ^0.4.11;
// Managed registry
// a registry for tracking items that an admin can prune as required
// @authors:
// Cody Burns <[email protected]>
// license: Apache 2.0
// usage:
//
// This managing contract is a general purpose token. Users can register the token address, symbol. decimal, type, and icon location(url for a set fee)
// It needs an owner who can assign Managers. Managers can edit token details. Output is all meta token data by item.
// still needs: improved item editing management, test framework, access levels for admins, all outputs for meta data, externalize admin to onlyAdmin contract
// submit pr and issues to https://github.com/realcodywburns/ETC-public-Works/edit/master/public-registry/manager.sol
contract owned{
address public owner;
function owned () {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender != owner) {
_;
}
}
}
contract priced {
modifier costs(uint price) {
if (msg.value < price) {
_;
}
}
}
contract Registry is priced, owned {
enum modActions { add, del, change, reprice }
uint64 public regCount; // running account check
uint public pendingReturns; // returns amount available for withdrawl
uint8 public adminCount; // check count of admins
uint public price; // the cost of each ticket is n ether.
struct Token{
address tokenAddress; // address of token contract
address saleAddress; // address to the crowdsale
string tokenName; // human readable name of token
string symbol; // token symbol
uint8 decimals; // how many decimal places
string standard; // token standard
string iconUrl; // url of image file for token if any
string siteUrl; // team website
string blerb; // about token
uint dateChanged; // last changed on
address changedBy; // last changed by
string changeReason; // notes on change
}
//mapping
mapping(uint => Token) public tokens;
mapping(uint8 => address) public admins;
//events
event newToken(address tokenAddress, address saleAddress, string tokenName, string symbol);
event modToken(address modName, address tokenAddress, address saleAddress, string tokenName, string symbol);
event delToken(address modName, string tokenName);
// anyone can add a token to the registry if the price is paid
function register(
address _tokenAddress,
address _saleAddress,
string _tokenName,
string _symbol,
uint8 _decimals,
string _standard,
string _iconUrl,
string _siteUrl,
string _blerb ) public payable costs(price)
{
logCoin(msg.sender, _tokenAddress, _saleAddress, _tokenName, _symbol, _decimals, _standard, _iconUrl, _siteUrl, _blerb);
}
function logCoin(
address _sender,
address _tokenAddress,
address _saleAddress,
string _tokenName,
string _symbol,
uint8 _decimals,
string _standard,
string _iconUrl,
string _siteUrl,
string _blerb ) internal
{
uint id = regCount++;
tokens[id] = Token({ // assigns the incoming token to the next available address
tokenAddress: _tokenAddress, // address of the main token contract
saleAddress: _saleAddress, // address of the crowd sale
tokenName: _tokenName, // human readable name of token
symbol: _symbol, // tickertape symbol
decimals: _decimals, // how many places
standard: _standard, // erc20 or erc223
iconUrl: _iconUrl, // should be a url to the token image
siteUrl: _siteUrl,
blerb: _blerb,
dateChanged: now,
changedBy: _sender,
changeReason: ""
});
pendingReturns += msg.value; // increases the owners balance
newToken(_tokenAddress, _saleAddress, _tokenName, _symbol); // announce token logged with an event
}
//only owner can get the funds stored on the contract
function withdraw() onlyOwner returns (bool) {
var amount = pendingReturns;
if (amount > 0) {
pendingReturns = 0;
if (!msg.sender.send(amount)) {
pendingReturns = amount;
return false;
}
}
return true;
}
// only the owner can add and remove the admins
function modAdmin(address _admin, modActions _action, uint8 _index) onlyOwner {
//options are add, del, change
if (_action == modActions.add){
uint8 id = adminCount++;
admins[id] = _admin;
}
if (_action == modActions.del){
delete admins[_index];
adminCount = adminCount - 1;
}
if (_action == modActions.change){
admins[_index] = _admin;
}
}
// admin managed functions
//manage the list in case something goes wrong (1)add (2)delete (3)change (4) ticketPrice
function modRegister(
address _tokenAddress,
address _saleAddress,
string _tokenName,
string _symbol,
uint8 _decimals,
string _standard,
string _iconUrl,
string _siteUrl,
string _blerb ) onlyAdmin
{
//this is the function adds contracts from the list for free
logCoin(msg.sender, _tokenAddress, _saleAddress, _tokenName, _symbol, _decimals, _standard, _iconUrl, _siteUrl, _blerb);
}
function modDelete (uint _index) onlyAdmin {
delete tokens[_index];
}
function modReprice (uint _reprice) onlyAdmin {
price = _reprice;
}
//modifiers
modifier onlyAdmin {
bool adminCheck = false;
for(uint8 i; i < adminCount; i ++){
if (msg.sender == admins[i]){
adminCheck = true;
}
}
if (!adminCheck) {
_;
}
}
//safety switches consider removing for production
//clean up after contract is no longer needed
function kill() public onlyOwner {selfdestruct(owner);}
}
| only the owner can add and remove the adminsoptions are add, del, change | function modAdmin(address _admin, modActions _action, uint8 _index) onlyOwner {
if (_action == modActions.add){
uint8 id = adminCount++;
admins[id] = _admin;
}
if (_action == modActions.del){
delete admins[_index];
adminCount = adminCount - 1;
}
if (_action == modActions.change){
admins[_index] = _admin;
}
}
| 2,497,944 | [
1,
3700,
326,
3410,
848,
527,
471,
1206,
326,
3981,
2048,
573,
854,
225,
527,
16,
225,
1464,
16,
2549,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
445,
681,
4446,
12,
2867,
389,
3666,
16,
681,
6100,
389,
1128,
16,
2254,
28,
389,
1615,
13,
1338,
5541,
288,
203,
1377,
309,
261,
67,
1128,
422,
681,
6100,
18,
1289,
15329,
203,
3639,
2254,
28,
612,
273,
3981,
1380,
9904,
31,
203,
3639,
31116,
63,
350,
65,
273,
389,
3666,
31,
203,
1377,
289,
203,
1377,
309,
261,
67,
1128,
422,
681,
6100,
18,
3771,
15329,
203,
3639,
1430,
31116,
63,
67,
1615,
15533,
203,
3639,
3981,
1380,
273,
3981,
1380,
300,
404,
31,
203,
1377,
289,
203,
1377,
309,
261,
67,
1128,
422,
681,
6100,
18,
3427,
15329,
203,
3639,
31116,
63,
67,
1615,
65,
273,
389,
3666,
31,
203,
1377,
289,
203,
225,
289,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
/**
*Submitted for verification at Etherscan.io on 2021-10-24
*/
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// Global Enums and Structs
struct StrategyParams {
uint256 performanceFee;
uint256 activation;
uint256 debtRatio;
uint256 minDebtPerHarvest;
uint256 maxDebtPerHarvest;
uint256 lastReport;
uint256 totalDebt;
uint256 totalGain;
uint256 totalLoss;
}
// Part: IBaseFee
interface IBaseFee {
function basefee_global() external view returns (uint256);
}
// Part: IConvexDeposit
interface IConvexDeposit {
// deposit into convex, receive a tokenized deposit. parameter to stake immediately (we always do this).
function deposit(
uint256 _pid,
uint256 _amount,
bool _stake
) external returns (bool);
// burn a tokenized deposit (Convex deposit tokens) to receive curve lp tokens back
function withdraw(uint256 _pid, uint256 _amount) external returns (bool);
// give us info about a pool based on its pid
function poolInfo(uint256)
external
view
returns (
address,
address,
address,
address,
address,
bool
);
}
// Part: IConvexRewards
interface IConvexRewards {
// strategy's staked balance in the synthetix staking contract
function balanceOf(address account) external view returns (uint256);
// read how much claimable CRV a strategy has
function earned(address account) external view returns (uint256);
// stake a convex tokenized deposit
function stake(uint256 _amount) external returns (bool);
// withdraw to a convex tokenized deposit, probably never need to use this
function withdraw(uint256 _amount, bool _claim) external returns (bool);
// withdraw directly to curve LP token, this is what we primarily use
function withdrawAndUnwrap(uint256 _amount, bool _claim)
external
returns (bool);
// claim rewards, with an option to claim extra rewards or not
function getReward(address _account, bool _claimExtras)
external
returns (bool);
}
// Part: ICurveFi
interface ICurveFi {
function get_virtual_price() external view returns (uint256);
function add_liquidity(
// Iron bank pool
uint256[2] calldata amounts,
uint256 min_mint_amount
) external payable;
function remove_liquidity_imbalance(
uint256[2] calldata amounts,
uint256 max_burn_amount
) external;
function remove_liquidity(uint256 _amount, uint256[2] calldata amounts)
external;
function remove_liquidity_one_coin(
uint256 _token_amount,
int128 i,
uint256 min_amount
) external;
function exchange(
int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount
) external;
function balances(uint256) external view returns (uint256);
function get_dy(
int128 from,
int128 to,
uint256 _from_amount
) external view returns (uint256);
function calc_token_amount(uint256[2] calldata amounts, bool _is_deposit)
external
view
returns (uint256);
function calc_withdraw_one_coin(uint256 amount, int128 i)
external
view
returns (uint256);
}
// Part: IUniswapV2Router01
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
// Part: OpenZeppelin/[email protected]/Address
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// Part: OpenZeppelin/[email protected]/IERC20
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Part: OpenZeppelin/[email protected]/Math
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// Part: OpenZeppelin/[email protected]/SafeMath
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// Part: yearn/[email protected]/HealthCheck
interface HealthCheck {
function check(
uint256 profit,
uint256 loss,
uint256 debtPayment,
uint256 debtOutstanding,
uint256 totalDebt
) external view returns (bool);
}
// Part: IUniswapV2Router02
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
// Part: OpenZeppelin/[email protected]/SafeERC20
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Part: yearn/[email protected]/VaultAPI
interface VaultAPI is IERC20 {
function name() external view returns (string calldata);
function symbol() external view returns (string calldata);
function decimals() external view returns (uint256);
function apiVersion() external pure returns (string memory);
function permit(
address owner,
address spender,
uint256 amount,
uint256 expiry,
bytes calldata signature
) external returns (bool);
// NOTE: Vyper produces multiple signatures for a given function with "default" args
function deposit() external returns (uint256);
function deposit(uint256 amount) external returns (uint256);
function deposit(uint256 amount, address recipient) external returns (uint256);
// NOTE: Vyper produces multiple signatures for a given function with "default" args
function withdraw() external returns (uint256);
function withdraw(uint256 maxShares) external returns (uint256);
function withdraw(uint256 maxShares, address recipient) external returns (uint256);
function token() external view returns (address);
function strategies(address _strategy) external view returns (StrategyParams memory);
function pricePerShare() external view returns (uint256);
function totalAssets() external view returns (uint256);
function depositLimit() external view returns (uint256);
function maxAvailableShares() external view returns (uint256);
/**
* View how much the Vault would increase this Strategy's borrow limit,
* based on its present performance (since its last report). Can be used to
* determine expectedReturn in your Strategy.
*/
function creditAvailable() external view returns (uint256);
/**
* View how much the Vault would like to pull back from the Strategy,
* based on its present performance (since its last report). Can be used to
* determine expectedReturn in your Strategy.
*/
function debtOutstanding() external view returns (uint256);
/**
* View how much the Vault expect this Strategy to return at the current
* block, based on its present performance (since its last report). Can be
* used to determine expectedReturn in your Strategy.
*/
function expectedReturn() external view returns (uint256);
/**
* This is the main contact point where the Strategy interacts with the
* Vault. It is critical that this call is handled as intended by the
* Strategy. Therefore, this function will be called by BaseStrategy to
* make sure the integration is correct.
*/
function report(
uint256 _gain,
uint256 _loss,
uint256 _debtPayment
) external returns (uint256);
/**
* This function should only be used in the scenario where the Strategy is
* being retired but no migration of the positions are possible, or in the
* extreme scenario that the Strategy needs to be put into "Emergency Exit"
* mode in order for it to exit as quickly as possible. The latter scenario
* could be for any reason that is considered "critical" that the Strategy
* exits its position as fast as possible, such as a sudden change in
* market conditions leading to losses, or an imminent failure in an
* external dependency.
*/
function revokeStrategy() external;
/**
* View the governance address of the Vault to assert privileged functions
* can only be called by governance. The Strategy serves the Vault, so it
* is subject to governance defined by the Vault.
*/
function governance() external view returns (address);
/**
* View the management address of the Vault to assert privileged functions
* can only be called by management. The Strategy serves the Vault, so it
* is subject to management defined by the Vault.
*/
function management() external view returns (address);
/**
* View the guardian address of the Vault to assert privileged functions
* can only be called by guardian. The Strategy serves the Vault, so it
* is subject to guardian defined by the Vault.
*/
function guardian() external view returns (address);
}
// Part: yearn/[email protected]/BaseStrategy
/**
* @title Yearn Base Strategy
* @author yearn.finance
* @notice
* BaseStrategy implements all of the required functionality to interoperate
* closely with the Vault contract. This contract should be inherited and the
* abstract methods implemented to adapt the Strategy to the particular needs
* it has to create a return.
*
* Of special interest is the relationship between `harvest()` and
* `vault.report()'. `harvest()` may be called simply because enough time has
* elapsed since the last report, and not because any funds need to be moved
* or positions adjusted. This is critical so that the Vault may maintain an
* accurate picture of the Strategy's performance. See `vault.report()`,
* `harvest()`, and `harvestTrigger()` for further details.
*/
abstract contract BaseStrategy {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public metadataURI;
// health checks
bool public doHealthCheck;
address public healthCheck;
/**
* @notice
* Used to track which version of `StrategyAPI` this Strategy
* implements.
* @dev The Strategy's version must match the Vault's `API_VERSION`.
* @return A string which holds the current API version of this contract.
*/
function apiVersion() public pure returns (string memory) {
return "0.4.3";
}
/**
* @notice This Strategy's name.
* @dev
* You can use this field to manage the "version" of this Strategy, e.g.
* `StrategySomethingOrOtherV1`. However, "API Version" is managed by
* `apiVersion()` function above.
* @return This Strategy's name.
*/
function name() external view virtual returns (string memory);
/**
* @notice
* The amount (priced in want) of the total assets managed by this strategy should not count
* towards Yearn's TVL calculations.
* @dev
* You can override this field to set it to a non-zero value if some of the assets of this
* Strategy is somehow delegated inside another part of of Yearn's ecosystem e.g. another Vault.
* Note that this value must be strictly less than or equal to the amount provided by
* `estimatedTotalAssets()` below, as the TVL calc will be total assets minus delegated assets.
* Also note that this value is used to determine the total assets under management by this
* strategy, for the purposes of computing the management fee in `Vault`
* @return
* The amount of assets this strategy manages that should not be included in Yearn's Total Value
* Locked (TVL) calculation across it's ecosystem.
*/
function delegatedAssets() external view virtual returns (uint256) {
return 0;
}
VaultAPI public vault;
address public strategist;
address public rewards;
address public keeper;
IERC20 public want;
// So indexers can keep track of this
event Harvested(uint256 profit, uint256 loss, uint256 debtPayment, uint256 debtOutstanding);
event UpdatedStrategist(address newStrategist);
event UpdatedKeeper(address newKeeper);
event UpdatedRewards(address rewards);
event UpdatedMinReportDelay(uint256 delay);
event UpdatedMaxReportDelay(uint256 delay);
event UpdatedProfitFactor(uint256 profitFactor);
event UpdatedDebtThreshold(uint256 debtThreshold);
event EmergencyExitEnabled();
event UpdatedMetadataURI(string metadataURI);
// The minimum number of seconds between harvest calls. See
// `setMinReportDelay()` for more details.
uint256 public minReportDelay;
// The maximum number of seconds between harvest calls. See
// `setMaxReportDelay()` for more details.
uint256 public maxReportDelay;
// The minimum multiple that `callCost` must be above the credit/profit to
// be "justifiable". See `setProfitFactor()` for more details.
uint256 public profitFactor;
// Use this to adjust the threshold at which running a debt causes a
// harvest trigger. See `setDebtThreshold()` for more details.
uint256 public debtThreshold;
// See note on `setEmergencyExit()`.
bool public emergencyExit;
// modifiers
modifier onlyAuthorized() {
require(msg.sender == strategist || msg.sender == governance(), "!authorized");
_;
}
modifier onlyEmergencyAuthorized() {
require(
msg.sender == strategist || msg.sender == governance() || msg.sender == vault.guardian() || msg.sender == vault.management(),
"!authorized"
);
_;
}
modifier onlyStrategist() {
require(msg.sender == strategist, "!strategist");
_;
}
modifier onlyGovernance() {
require(msg.sender == governance(), "!authorized");
_;
}
modifier onlyKeepers() {
require(
msg.sender == keeper ||
msg.sender == strategist ||
msg.sender == governance() ||
msg.sender == vault.guardian() ||
msg.sender == vault.management(),
"!authorized"
);
_;
}
modifier onlyVaultManagers() {
require(msg.sender == vault.management() || msg.sender == governance(), "!authorized");
_;
}
constructor(address _vault) public {
_initialize(_vault, msg.sender, msg.sender, msg.sender);
}
/**
* @notice
* Initializes the Strategy, this is called only once, when the
* contract is deployed.
* @dev `_vault` should implement `VaultAPI`.
* @param _vault The address of the Vault responsible for this Strategy.
* @param _strategist The address to assign as `strategist`.
* The strategist is able to change the reward address
* @param _rewards The address to use for pulling rewards.
* @param _keeper The adddress of the _keeper. _keeper
* can harvest and tend a strategy.
*/
function _initialize(
address _vault,
address _strategist,
address _rewards,
address _keeper
) internal {
require(address(want) == address(0), "Strategy already initialized");
vault = VaultAPI(_vault);
want = IERC20(vault.token());
want.safeApprove(_vault, uint256(-1)); // Give Vault unlimited access (might save gas)
strategist = _strategist;
rewards = _rewards;
keeper = _keeper;
// initialize variables
minReportDelay = 0;
maxReportDelay = 86400;
profitFactor = 100;
debtThreshold = 0;
vault.approve(rewards, uint256(-1)); // Allow rewards to be pulled
}
function setHealthCheck(address _healthCheck) external onlyVaultManagers {
healthCheck = _healthCheck;
}
function setDoHealthCheck(bool _doHealthCheck) external onlyVaultManagers {
doHealthCheck = _doHealthCheck;
}
/**
* @notice
* Used to change `strategist`.
*
* This may only be called by governance or the existing strategist.
* @param _strategist The new address to assign as `strategist`.
*/
function setStrategist(address _strategist) external onlyAuthorized {
require(_strategist != address(0));
strategist = _strategist;
emit UpdatedStrategist(_strategist);
}
/**
* @notice
* Used to change `keeper`.
*
* `keeper` is the only address that may call `tend()` or `harvest()`,
* other than `governance()` or `strategist`. However, unlike
* `governance()` or `strategist`, `keeper` may *only* call `tend()`
* and `harvest()`, and no other authorized functions, following the
* principle of least privilege.
*
* This may only be called by governance or the strategist.
* @param _keeper The new address to assign as `keeper`.
*/
function setKeeper(address _keeper) external onlyAuthorized {
require(_keeper != address(0));
keeper = _keeper;
emit UpdatedKeeper(_keeper);
}
/**
* @notice
* Used to change `rewards`. EOA or smart contract which has the permission
* to pull rewards from the vault.
*
* This may only be called by the strategist.
* @param _rewards The address to use for pulling rewards.
*/
function setRewards(address _rewards) external onlyStrategist {
require(_rewards != address(0));
vault.approve(rewards, 0);
rewards = _rewards;
vault.approve(rewards, uint256(-1));
emit UpdatedRewards(_rewards);
}
/**
* @notice
* Used to change `minReportDelay`. `minReportDelay` is the minimum number
* of blocks that should pass for `harvest()` to be called.
*
* For external keepers (such as the Keep3r network), this is the minimum
* time between jobs to wait. (see `harvestTrigger()`
* for more details.)
*
* This may only be called by governance or the strategist.
* @param _delay The minimum number of seconds to wait between harvests.
*/
function setMinReportDelay(uint256 _delay) external onlyAuthorized {
minReportDelay = _delay;
emit UpdatedMinReportDelay(_delay);
}
/**
* @notice
* Used to change `maxReportDelay`. `maxReportDelay` is the maximum number
* of blocks that should pass for `harvest()` to be called.
*
* For external keepers (such as the Keep3r network), this is the maximum
* time between jobs to wait. (see `harvestTrigger()`
* for more details.)
*
* This may only be called by governance or the strategist.
* @param _delay The maximum number of seconds to wait between harvests.
*/
function setMaxReportDelay(uint256 _delay) external onlyAuthorized {
maxReportDelay = _delay;
emit UpdatedMaxReportDelay(_delay);
}
/**
* @notice
* Used to change `profitFactor`. `profitFactor` is used to determine
* if it's worthwhile to harvest, given gas costs. (See `harvestTrigger()`
* for more details.)
*
* This may only be called by governance or the strategist.
* @param _profitFactor A ratio to multiply anticipated
* `harvest()` gas cost against.
*/
function setProfitFactor(uint256 _profitFactor) external onlyAuthorized {
profitFactor = _profitFactor;
emit UpdatedProfitFactor(_profitFactor);
}
/**
* @notice
* Sets how far the Strategy can go into loss without a harvest and report
* being required.
*
* By default this is 0, meaning any losses would cause a harvest which
* will subsequently report the loss to the Vault for tracking. (See
* `harvestTrigger()` for more details.)
*
* This may only be called by governance or the strategist.
* @param _debtThreshold How big of a loss this Strategy may carry without
* being required to report to the Vault.
*/
function setDebtThreshold(uint256 _debtThreshold) external onlyAuthorized {
debtThreshold = _debtThreshold;
emit UpdatedDebtThreshold(_debtThreshold);
}
/**
* @notice
* Used to change `metadataURI`. `metadataURI` is used to store the URI
* of the file describing the strategy.
*
* This may only be called by governance or the strategist.
* @param _metadataURI The URI that describe the strategy.
*/
function setMetadataURI(string calldata _metadataURI) external onlyAuthorized {
metadataURI = _metadataURI;
emit UpdatedMetadataURI(_metadataURI);
}
/**
* Resolve governance address from Vault contract, used to make assertions
* on protected functions in the Strategy.
*/
function governance() internal view returns (address) {
return vault.governance();
}
/**
* @notice
* Provide an accurate conversion from `_amtInWei` (denominated in wei)
* to `want` (using the native decimal characteristics of `want`).
* @dev
* Care must be taken when working with decimals to assure that the conversion
* is compatible. As an example:
*
* given 1e17 wei (0.1 ETH) as input, and want is USDC (6 decimals),
* with USDC/ETH = 1800, this should give back 1800000000 (180 USDC)
*
* @param _amtInWei The amount (in wei/1e-18 ETH) to convert to `want`
* @return The amount in `want` of `_amtInEth` converted to `want`
**/
function ethToWant(uint256 _amtInWei) public view virtual returns (uint256);
/**
* @notice
* Provide an accurate estimate for the total amount of assets
* (principle + return) that this Strategy is currently managing,
* denominated in terms of `want` tokens.
*
* This total should be "realizable" e.g. the total value that could
* *actually* be obtained from this Strategy if it were to divest its
* entire position based on current on-chain conditions.
* @dev
* Care must be taken in using this function, since it relies on external
* systems, which could be manipulated by the attacker to give an inflated
* (or reduced) value produced by this function, based on current on-chain
* conditions (e.g. this function is possible to influence through
* flashloan attacks, oracle manipulations, or other DeFi attack
* mechanisms).
*
* It is up to governance to use this function to correctly order this
* Strategy relative to its peers in the withdrawal queue to minimize
* losses for the Vault based on sudden withdrawals. This value should be
* higher than the total debt of the Strategy and higher than its expected
* value to be "safe".
* @return The estimated total assets in this Strategy.
*/
function estimatedTotalAssets() public view virtual returns (uint256);
/*
* @notice
* Provide an indication of whether this strategy is currently "active"
* in that it is managing an active position, or will manage a position in
* the future. This should correlate to `harvest()` activity, so that Harvest
* events can be tracked externally by indexing agents.
* @return True if the strategy is actively managing a position.
*/
function isActive() public view returns (bool) {
return vault.strategies(address(this)).debtRatio > 0 || estimatedTotalAssets() > 0;
}
/**
* Perform any Strategy unwinding or other calls necessary to capture the
* "free return" this Strategy has generated since the last time its core
* position(s) were adjusted. Examples include unwrapping extra rewards.
* This call is only used during "normal operation" of a Strategy, and
* should be optimized to minimize losses as much as possible.
*
* This method returns any realized profits and/or realized losses
* incurred, and should return the total amounts of profits/losses/debt
* payments (in `want` tokens) for the Vault's accounting (e.g.
* `want.balanceOf(this) >= _debtPayment + _profit`).
*
* `_debtOutstanding` will be 0 if the Strategy is not past the configured
* debt limit, otherwise its value will be how far past the debt limit
* the Strategy is. The Strategy's debt limit is configured in the Vault.
*
* NOTE: `_debtPayment` should be less than or equal to `_debtOutstanding`.
* It is okay for it to be less than `_debtOutstanding`, as that
* should only used as a guide for how much is left to pay back.
* Payments should be made to minimize loss from slippage, debt,
* withdrawal fees, etc.
*
* See `vault.debtOutstanding()`.
*/
function prepareReturn(uint256 _debtOutstanding)
internal
virtual
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
);
/**
* Perform any adjustments to the core position(s) of this Strategy given
* what change the Vault made in the "investable capital" available to the
* Strategy. Note that all "free capital" in the Strategy after the report
* was made is available for reinvestment. Also note that this number
* could be 0, and you should handle that scenario accordingly.
*
* See comments regarding `_debtOutstanding` on `prepareReturn()`.
*/
function adjustPosition(uint256 _debtOutstanding) internal virtual;
/**
* Liquidate up to `_amountNeeded` of `want` of this strategy's positions,
* irregardless of slippage. Any excess will be re-invested with `adjustPosition()`.
* This function should return the amount of `want` tokens made available by the
* liquidation. If there is a difference between them, `_loss` indicates whether the
* difference is due to a realized loss, or if there is some other sitution at play
* (e.g. locked funds) where the amount made available is less than what is needed.
*
* NOTE: The invariant `_liquidatedAmount + _loss <= _amountNeeded` should always be maintained
*/
function liquidatePosition(uint256 _amountNeeded) internal virtual returns (uint256 _liquidatedAmount, uint256 _loss);
/**
* Liquidate everything and returns the amount that got freed.
* This function is used during emergency exit instead of `prepareReturn()` to
* liquidate all of the Strategy's positions back to the Vault.
*/
function liquidateAllPositions() internal virtual returns (uint256 _amountFreed);
/**
* @notice
* Provide a signal to the keeper that `tend()` should be called. The
* keeper will provide the estimated gas cost that they would pay to call
* `tend()`, and this function should use that estimate to make a
* determination if calling it is "worth it" for the keeper. This is not
* the only consideration into issuing this trigger, for example if the
* position would be negatively affected if `tend()` is not called
* shortly, then this can return `true` even if the keeper might be
* "at a loss" (keepers are always reimbursed by Yearn).
* @dev
* `callCostInWei` must be priced in terms of `wei` (1e-18 ETH).
*
* This call and `harvestTrigger()` should never return `true` at the same
* time.
* @param callCostInWei The keeper's estimated gas cost to call `tend()` (in wei).
* @return `true` if `tend()` should be called, `false` otherwise.
*/
function tendTrigger(uint256 callCostInWei) public view virtual returns (bool) {
// 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.
// If your implementation uses the cost of the call in want, you can
// use uint256 callCost = ethToWant(callCostInWei);
return false;
}
/**
* @notice
* Adjust the Strategy's position. The purpose of tending isn't to
* realize gains, but to maximize yield by reinvesting any returns.
*
* See comments on `adjustPosition()`.
*
* This may only be called by governance, the strategist, or the keeper.
*/
function tend() external onlyKeepers {
// Don't take profits with this call, but adjust for better gains
adjustPosition(vault.debtOutstanding());
}
/**
* @notice
* Provide a signal to the keeper that `harvest()` should be called. The
* keeper will provide the estimated gas cost that they would pay to call
* `harvest()`, and this function should use that estimate to make a
* determination if calling it is "worth it" for the keeper. This is not
* the only consideration into issuing this trigger, for example if the
* position would be negatively affected if `harvest()` is not called
* shortly, then this can return `true` even if the keeper might be "at a
* loss" (keepers are always reimbursed by Yearn).
* @dev
* `callCostInWei` must be priced in terms of `wei` (1e-18 ETH).
*
* This call and `tendTrigger` should never return `true` at the
* same time.
*
* See `min/maxReportDelay`, `profitFactor`, `debtThreshold` to adjust the
* strategist-controlled parameters that will influence whether this call
* returns `true` or not. These parameters will be used in conjunction
* with the parameters reported to the Vault (see `params`) to determine
* if calling `harvest()` is merited.
*
* It is expected that an external system will check `harvestTrigger()`.
* This could be a script run off a desktop or cloud bot (e.g.
* https://github.com/iearn-finance/yearn-vaults/blob/main/scripts/keep.py),
* or via an integration with the Keep3r network (e.g.
* https://github.com/Macarse/GenericKeep3rV2/blob/master/contracts/keep3r/GenericKeep3rV2.sol).
* @param callCostInWei The keeper's estimated gas cost to call `harvest()` (in wei).
* @return `true` if `harvest()` should be called, `false` otherwise.
*/
function harvestTrigger(uint256 callCostInWei) public view virtual returns (bool) {
uint256 callCost = ethToWant(callCostInWei);
StrategyParams memory params = vault.strategies(address(this));
// Should not trigger if Strategy is not activated
if (params.activation == 0) return false;
// Should not trigger if we haven't waited long enough since previous harvest
if (block.timestamp.sub(params.lastReport) < minReportDelay) return false;
// Should trigger if hasn't been called in a while
if (block.timestamp.sub(params.lastReport) >= maxReportDelay) return true;
// If some amount is owed, pay it back
// NOTE: Since debt is based on deposits, it makes sense to guard against large
// changes to the value from triggering a harvest directly through user
// behavior. This should ensure reasonable resistance to manipulation
// from user-initiated withdrawals as the outstanding debt fluctuates.
uint256 outstanding = vault.debtOutstanding();
if (outstanding > debtThreshold) return true;
// Check for profits and losses
uint256 total = estimatedTotalAssets();
// Trigger if we have a loss to report
if (total.add(debtThreshold) < params.totalDebt) return true;
uint256 profit = 0;
if (total > params.totalDebt) profit = total.sub(params.totalDebt); // We've earned a profit!
// Otherwise, only trigger if it "makes sense" economically (gas cost
// is <N% of value moved)
uint256 credit = vault.creditAvailable();
return (profitFactor.mul(callCost) < credit.add(profit));
}
/**
* @notice
* Harvests the Strategy, recognizing any profits or losses and adjusting
* the Strategy's position.
*
* In the rare case the Strategy is in emergency shutdown, this will exit
* the Strategy's position.
*
* This may only be called by governance, the strategist, or the keeper.
* @dev
* When `harvest()` is called, the Strategy reports to the Vault (via
* `vault.report()`), so in some cases `harvest()` must be called in order
* to take in profits, to borrow newly available funds from the Vault, or
* otherwise adjust its position. In other cases `harvest()` must be
* called to report to the Vault on the Strategy's position, especially if
* any losses have occurred.
*/
function harvest() external onlyKeepers {
uint256 profit = 0;
uint256 loss = 0;
uint256 debtOutstanding = vault.debtOutstanding();
uint256 debtPayment = 0;
if (emergencyExit) {
// Free up as much capital as possible
uint256 amountFreed = liquidateAllPositions();
if (amountFreed < debtOutstanding) {
loss = debtOutstanding.sub(amountFreed);
} else if (amountFreed > debtOutstanding) {
profit = amountFreed.sub(debtOutstanding);
}
debtPayment = debtOutstanding.sub(loss);
} else {
// Free up returns for Vault to pull
(profit, loss, debtPayment) = prepareReturn(debtOutstanding);
}
// Allow Vault to take up to the "harvested" balance of this contract,
// which is the amount it has earned since the last time it reported to
// the Vault.
uint256 totalDebt = vault.strategies(address(this)).totalDebt;
debtOutstanding = vault.report(profit, loss, debtPayment);
// Check if free returns are left, and re-invest them
adjustPosition(debtOutstanding);
// call healthCheck contract
if (doHealthCheck && healthCheck != address(0)) {
require(HealthCheck(healthCheck).check(profit, loss, debtPayment, debtOutstanding, totalDebt), "!healthcheck");
} else {
doHealthCheck = true;
}
emit Harvested(profit, loss, debtPayment, debtOutstanding);
}
/**
* @notice
* Withdraws `_amountNeeded` to `vault`.
*
* This may only be called by the Vault.
* @param _amountNeeded How much `want` to withdraw.
* @return _loss Any realized losses
*/
function withdraw(uint256 _amountNeeded) external returns (uint256 _loss) {
require(msg.sender == address(vault), "!vault");
// Liquidate as much as possible to `want`, up to `_amountNeeded`
uint256 amountFreed;
(amountFreed, _loss) = liquidatePosition(_amountNeeded);
// Send it directly back (NOTE: Using `msg.sender` saves some gas here)
want.safeTransfer(msg.sender, amountFreed);
// NOTE: Reinvest anything leftover on next `tend`/`harvest`
}
/**
* Do anything necessary to prepare this Strategy for migration, such as
* transferring any reserve or LP tokens, CDPs, or other tokens or stores of
* value.
*/
function prepareMigration(address _newStrategy) internal virtual;
/**
* @notice
* Transfers all `want` from this Strategy to `_newStrategy`.
*
* This may only be called by the Vault.
* @dev
* The new Strategy's Vault must be the same as this Strategy's Vault.
* The migration process should be carefully performed to make sure all
* the assets are migrated to the new address, which should have never
* interacted with the vault before.
* @param _newStrategy The Strategy to migrate to.
*/
function migrate(address _newStrategy) external {
require(msg.sender == address(vault));
require(BaseStrategy(_newStrategy).vault() == vault);
prepareMigration(_newStrategy);
want.safeTransfer(_newStrategy, want.balanceOf(address(this)));
}
/**
* @notice
* Activates emergency exit. Once activated, the Strategy will exit its
* position upon the next harvest, depositing all funds into the Vault as
* quickly as is reasonable given on-chain conditions.
*
* This may only be called by governance or the strategist.
* @dev
* See `vault.setEmergencyShutdown()` and `harvest()` for further details.
*/
function setEmergencyExit() external onlyEmergencyAuthorized {
emergencyExit = true;
vault.revokeStrategy();
emit EmergencyExitEnabled();
}
/**
* Override this to add all tokens/tokenized positions this contract
* manages on a *persistent* basis (e.g. not just for swapping back to
* want ephemerally).
*
* NOTE: Do *not* include `want`, already included in `sweep` below.
*
* Example:
* ```
* function protectedTokens() internal override view returns (address[] memory) {
* address[] memory protected = new address[](3);
* protected[0] = tokenA;
* protected[1] = tokenB;
* protected[2] = tokenC;
* return protected;
* }
* ```
*/
function protectedTokens() internal view virtual returns (address[] memory);
/**
* @notice
* Removes tokens from this Strategy that are not the type of tokens
* managed by this Strategy. This may be used in case of accidentally
* sending the wrong kind of token to this Strategy.
*
* Tokens will be sent to `governance()`.
*
* This will fail if an attempt is made to sweep `want`, or any tokens
* that are protected by this Strategy.
*
* This may only be called by governance.
* @dev
* Implement `protectedTokens()` to specify any additional tokens that
* should be protected from sweeping in addition to `want`.
* @param _token The token to transfer out of this vault.
*/
function sweep(address _token) external onlyGovernance {
require(_token != address(want), "!want");
require(_token != address(vault), "!shares");
address[] memory _protectedTokens = protectedTokens();
for (uint256 i; i < _protectedTokens.length; i++) require(_token != _protectedTokens[i], "!protected");
IERC20(_token).safeTransfer(governance(), IERC20(_token).balanceOf(address(this)));
}
}
// Part: StrategyConvexBase
abstract contract StrategyConvexBase is BaseStrategy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
/* ========== STATE VARIABLES ========== */
// these should stay the same across different wants.
// convex stuff
address public constant depositContract =
0xF403C135812408BFbE8713b5A23a04b3D48AAE31; // this is the deposit contract that all pools use, aka booster
address public rewardsContract; // This is unique to each curve pool
uint256 public pid; // this is unique to each pool
// keepCRV stuff
uint256 public keepCRV; // the percentage of CRV we re-lock for boost (in basis points)
address public constant voter = 0xF147b8125d2ef93FB6965Db97D6746952a133934; // Yearn's veCRV voter, we send some extra CRV here
uint256 internal constant FEE_DENOMINATOR = 10000; // this means all of our fee values are in bips
// Swap stuff
address internal constant sushiswap =
0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F; // default to sushiswap, more CRV and CVX liquidity there
IERC20 internal constant crv =
IERC20(0xD533a949740bb3306d119CC777fa900bA034cd52);
IERC20 internal constant convexToken =
IERC20(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B);
IERC20 internal constant weth =
IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
// keeper stuff
uint256 public harvestProfitNeeded; // we use this to set our dollar target (in USDT) for harvest sells
bool internal forceHarvestTriggerOnce; // only set this to true when we want to trigger our keepers to harvest for us
string internal stratName; // we use this to be able to adjust our strategy's name
// convex-specific variables
bool public claimRewards; // boolean if we should always claim rewards when withdrawing, usually withdrawAndUnwrap (generally this should be false)
/* ========== CONSTRUCTOR ========== */
constructor(address _vault) public BaseStrategy(_vault) {}
/* ========== VIEWS ========== */
function name() external view override returns (string memory) {
return stratName;
}
function stakedBalance() public view returns (uint256) {
// how much want we have staked in Convex
return IConvexRewards(rewardsContract).balanceOf(address(this));
}
function balanceOfWant() public view returns (uint256) {
// balance of want sitting in our strategy
return want.balanceOf(address(this));
}
function claimableBalance() public view returns (uint256) {
// how much CRV we can claim from the staking contract
return IConvexRewards(rewardsContract).earned(address(this));
}
function estimatedTotalAssets() public view override returns (uint256) {
return balanceOfWant().add(stakedBalance());
}
/* ========== CONSTANT FUNCTIONS ========== */
// these should stay the same across different wants.
function adjustPosition(uint256 _debtOutstanding) internal override {
if (emergencyExit) {
return;
}
// Send all of our Curve pool tokens to be deposited
uint256 _toInvest = balanceOfWant();
// deposit into convex and stake immediately but only if we have something to invest
if (_toInvest > 0) {
IConvexDeposit(depositContract).deposit(pid, _toInvest, true);
}
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
uint256 _wantBal = balanceOfWant();
if (_amountNeeded > _wantBal) {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
IConvexRewards(rewardsContract).withdrawAndUnwrap(
Math.min(_stakedBal, _amountNeeded.sub(_wantBal)),
claimRewards
);
}
uint256 _withdrawnBal = balanceOfWant();
_liquidatedAmount = Math.min(_amountNeeded, _withdrawnBal);
_loss = _amountNeeded.sub(_liquidatedAmount);
} else {
// we have enough balance to cover the liquidation available
return (_amountNeeded, 0);
}
}
// fire sale, get rid of it all!
function liquidateAllPositions() internal override returns (uint256) {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
// don't bother withdrawing zero
IConvexRewards(rewardsContract).withdrawAndUnwrap(
_stakedBal,
claimRewards
);
}
return balanceOfWant();
}
// in case we need to exit into the convex deposit token, this will allow us to do that
// make sure to check claimRewards before this step if needed
// plan to have gov sweep convex deposit tokens from strategy after this
function withdrawToConvexDepositTokens() external onlyAuthorized {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
IConvexRewards(rewardsContract).withdraw(_stakedBal, claimRewards);
}
}
// we don't want for these tokens to be swept out. We allow gov to sweep out cvx vault tokens; we would only be holding these if things were really, really rekt.
function protectedTokens()
internal
view
override
returns (address[] memory)
{
return new address[](0);
}
/* ========== SETTERS ========== */
// These functions are useful for setting parameters of the strategy that may need to be adjusted.
// Set the amount of CRV to be locked in Yearn's veCRV voter from each harvest. Default is 10%.
function setKeepCRV(uint256 _keepCRV) external onlyAuthorized {
require(_keepCRV <= 10_000);
keepCRV = _keepCRV;
}
// We usually don't need to claim rewards on withdrawals, but might change our mind for migrations etc
function setClaimRewards(bool _claimRewards) external onlyAuthorized {
claimRewards = _claimRewards;
}
// This determines when we tell our keepers to harvest based on profit. this is how much in USDT we need to make. remember, 6 decimals!
function setHarvestProfitNeeded(uint256 _harvestProfitNeeded)
external
onlyAuthorized
{
harvestProfitNeeded = _harvestProfitNeeded;
}
// This allows us to manually harvest with our keeper as needed
function setForceHarvestTriggerOnce(bool _forceHarvestTriggerOnce)
external
onlyAuthorized
{
forceHarvestTriggerOnce = _forceHarvestTriggerOnce;
}
}
// File: StrategyConvexalETH.sol
contract StrategyConvexalETH is StrategyConvexBase {
/* ========== STATE VARIABLES ========== */
// these will likely change across different wants.
ICurveFi public curve; // Curve Pool, need this for buying more pool tokens
uint256 public maxGasPrice; // this is the max gas price we want our keepers to pay for harvests/tends in gwei
// used to check value of pending harvest
IERC20 internal constant usdt =
IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
/* ========== CONSTRUCTOR ========== */
constructor(
address _vault,
uint256 _pid,
address _curvePool,
string memory _name
) public StrategyConvexBase(_vault) {
// You can set these parameters on deployment to whatever you want
maxReportDelay = 7 days; // 7 days in seconds, if we hit this then harvestTrigger = True
debtThreshold = 1 * 1e6; // we shouldn't ever have debt, but set a bit of a buffer
profitFactor = 1_000_000; // in this strategy, profitFactor is only used for telling keep3rs when to move funds from vault to strategy
harvestProfitNeeded = 80_000 * 1e6; // this is how much in USDT we need to make. remember, 6 decimals!
healthCheck = 0xDDCea799fF1699e98EDF118e0629A974Df7DF012; // health.ychad.eth
// want = Curve LP
want.approve(address(depositContract), type(uint256).max);
crv.approve(sushiswap, type(uint256).max);
convexToken.approve(sushiswap, type(uint256).max);
// set our keepCRV
keepCRV = 1000;
// this is the pool specific to this vault, used for depositing
curve = ICurveFi(_curvePool);
// setup our rewards contract
pid = _pid; // this is the pool ID on convex, we use this to determine what the reweardsContract address is
address lptoken;
(lptoken, , , rewardsContract, , ) = IConvexDeposit(depositContract)
.poolInfo(_pid);
// check that our LP token based on our pid matches our want
require(address(lptoken) == address(want));
// set our strategy's name
stratName = _name;
// set our max gas price
maxGasPrice = 100 * 1e9;
}
/* ========== VARIABLE FUNCTIONS ========== */
// these will likely change across different wants.
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
// if we have anything staked, then harvest CRV and CVX from the rewards contract
if (claimableBalance() > 0) {
// this claims our CRV, CVX, and any extra tokens like SNX or ANKR. set to false if these tokens don't exist, true if they do.
IConvexRewards(rewardsContract).getReward(address(this), false);
uint256 crvBalance = crv.balanceOf(address(this));
uint256 convexBalance = convexToken.balanceOf(address(this));
uint256 _sendToVoter = crvBalance.mul(keepCRV).div(FEE_DENOMINATOR);
if (_sendToVoter > 0) {
crv.safeTransfer(voter, _sendToVoter);
}
uint256 crvRemainder = crvBalance.sub(_sendToVoter);
if (crvRemainder > 0) {
_sellCrvforETH(crvRemainder);
}
if (convexBalance > 0) {
_sellConvexforETH(convexBalance);
}
// deposit our ETH to the curve pool
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {
curve.add_liquidity{value: ethBalance}([ethBalance, 0], 0);
}
}
// debtOustanding will only be > 0 in the event of revoking or if we need to rebalance from a withdrawal or lowering the debtRatio
if (_debtOutstanding > 0) {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
IConvexRewards(rewardsContract).withdrawAndUnwrap(
Math.min(_stakedBal, _debtOutstanding),
claimRewards
);
}
uint256 _withdrawnBal = balanceOfWant();
_debtPayment = Math.min(_debtOutstanding, _withdrawnBal);
}
// serious loss should never happen, but if it does (for instance, if Curve is hacked), let's record it accurately
uint256 assets = estimatedTotalAssets();
uint256 debt = vault.strategies(address(this)).totalDebt;
// if assets are greater than debt, things are working great!
if (assets > debt) {
_profit = assets.sub(debt);
uint256 _wantBal = balanceOfWant();
if (_profit.add(_debtPayment) > _wantBal) {
// this should only be hit following donations to strategy
liquidateAllPositions();
}
}
// if assets are less than debt, we are in trouble
else {
_loss = debt.sub(assets);
}
// we're done harvesting, so reset our trigger if we used it
forceHarvestTriggerOnce = false;
}
// Sells our harvested CRV into the selected output (ETH).
function _sellCrvforETH(uint256 _crvAmount) internal {
address[] memory crvPath = new address[](2);
crvPath[0] = address(crv);
crvPath[1] = address(weth);
IUniswapV2Router02(sushiswap).swapExactTokensForETH(
_crvAmount,
uint256(0),
crvPath,
address(this),
block.timestamp
);
}
// Sells our harvested CVX into the selected output (ETH).
function _sellConvexforETH(uint256 _convexAmount) internal {
address[] memory convexTokenPath = new address[](2);
convexTokenPath[0] = address(convexToken);
convexTokenPath[1] = address(weth);
IUniswapV2Router02(sushiswap).swapExactTokensForETH(
_convexAmount,
uint256(0),
convexTokenPath,
address(this),
block.timestamp
);
}
// migrate our want token to a new strategy if needed, make sure to check claimRewards first
// also send over any CRV or CVX that is claimed; for migrations we definitely want to claim
function prepareMigration(address _newStrategy) internal override {
uint256 _stakedBal = stakedBalance();
if (_stakedBal > 0) {
IConvexRewards(rewardsContract).withdrawAndUnwrap(
_stakedBal,
claimRewards
);
}
crv.safeTransfer(_newStrategy, crv.balanceOf(address(this)));
convexToken.safeTransfer(
_newStrategy,
convexToken.balanceOf(address(this))
);
}
/* ========== KEEP3RS ========== */
function harvestTrigger(uint256 callCostinEth)
public
view
override
returns (bool)
{
// trigger if we want to manually harvest
if (forceHarvestTriggerOnce) {
return true;
}
// harvest if we have a profit to claim
if (claimableProfitInUsdt() > harvestProfitNeeded) {
return true;
}
// Should not trigger if strategy is not active (no assets and no debtRatio). This means we don't need to adjust keeper job.
if (!isActive()) {
return false;
}
// check if the base fee gas price is higher than we allow
if (readBaseFee() > maxGasPrice) {
return false;
}
return super.harvestTrigger(callCostinEth);
}
function readBaseFee() internal view returns (uint256 baseFee) {
IBaseFee _baseFeeOracle =
IBaseFee(0xf8d0Ec04e94296773cE20eFbeeA82e76220cD549);
return _baseFeeOracle.basefee_global();
}
// we will need to add rewards token here if we have them
function claimableProfitInUsdt() internal view returns (uint256) {
// calculations pulled directly from CVX's contract for minting CVX per CRV claimed
uint256 totalCliffs = 1_000;
uint256 maxSupply = 100 * 1_000_000 * 1e18; // 100mil
uint256 reductionPerCliff = 100_000 * 1e18; // 100,000
uint256 supply = convexToken.totalSupply();
uint256 mintableCvx;
uint256 cliff = supply.div(reductionPerCliff);
uint256 _claimableBal = claimableBalance();
//mint if below total cliffs
if (cliff < totalCliffs) {
//for reduction% take inverse of current cliff
uint256 reduction = totalCliffs.sub(cliff);
//reduce
mintableCvx = _claimableBal.mul(reduction).div(totalCliffs);
//supply cap check
uint256 amtTillMax = maxSupply.sub(supply);
if (mintableCvx > amtTillMax) {
mintableCvx = amtTillMax;
}
}
address[] memory crv_usd_path = new address[](3);
crv_usd_path[0] = address(crv);
crv_usd_path[1] = address(weth);
crv_usd_path[2] = address(usdt);
address[] memory cvx_usd_path = new address[](3);
cvx_usd_path[0] = address(convexToken);
cvx_usd_path[1] = address(weth);
cvx_usd_path[2] = address(usdt);
uint256 crvValue;
if (_claimableBal > 0) {
uint256[] memory crvSwap =
IUniswapV2Router02(sushiswap).getAmountsOut(
_claimableBal,
crv_usd_path
);
crvValue = crvSwap[crvSwap.length - 1];
}
uint256 cvxValue;
if (mintableCvx > 0) {
uint256[] memory cvxSwap =
IUniswapV2Router02(sushiswap).getAmountsOut(
mintableCvx,
cvx_usd_path
);
cvxValue = cvxSwap[cvxSwap.length - 1];
}
return crvValue.add(cvxValue);
}
// convert our keeper's eth cost into want
function ethToWant(uint256 _ethAmount)
public
view
override
returns (uint256)
{
uint256 callCostInWant;
if (_ethAmount > 0) {
callCostInWant = curve.calc_token_amount([_ethAmount, 0], true);
}
return callCostInWant;
}
// enable ability to recieve ETH
receive() external payable {}
/* ========== SETTERS ========== */
// set the maximum gas price we want to pay for a harvest/tend in gwei
function setGasPrice(uint256 _maxGasPrice) external onlyAuthorized {
maxGasPrice = _maxGasPrice.mul(1e9);
}
} | ========== CONSTRUCTOR ========== */ You can set these parameters on deployment to whatever you want want = Curve LP set our keepCRV this is the pool specific to this vault, used for depositing setup our rewards contract check that our LP token based on our pid matches our want set our strategy's name set our max gas price | ) public StrategyConvexBase(_vault) {
want.approve(address(depositContract), type(uint256).max);
crv.approve(sushiswap, type(uint256).max);
convexToken.approve(sushiswap, type(uint256).max);
keepCRV = 1000;
curve = ICurveFi(_curvePool);
address lptoken;
(lptoken, , , rewardsContract, , ) = IConvexDeposit(depositContract)
.poolInfo(_pid);
require(address(lptoken) == address(want));
stratName = _name;
maxGasPrice = 100 * 1e9;
}
| 10,934,267 | [
1,
1432,
631,
3492,
13915,
916,
422,
1432,
342,
4554,
848,
444,
4259,
1472,
603,
6314,
358,
15098,
1846,
2545,
2545,
273,
22901,
511,
52,
444,
3134,
3455,
5093,
58,
333,
353,
326,
2845,
2923,
358,
333,
9229,
16,
1399,
364,
443,
1724,
310,
3875,
3134,
283,
6397,
6835,
866,
716,
3134,
511,
52,
1147,
2511,
603,
3134,
4231,
1885,
3134,
2545,
444,
3134,
6252,
1807,
508,
444,
3134,
943,
16189,
6205,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
262,
1071,
19736,
17467,
338,
2171,
24899,
26983,
13,
288,
203,
203,
3639,
2545,
18,
12908,
537,
12,
2867,
12,
323,
1724,
8924,
3631,
618,
12,
11890,
5034,
2934,
1896,
1769,
203,
3639,
4422,
90,
18,
12908,
537,
12,
87,
1218,
291,
91,
438,
16,
618,
12,
11890,
5034,
2934,
1896,
1769,
203,
3639,
26213,
1345,
18,
12908,
537,
12,
87,
1218,
291,
91,
438,
16,
618,
12,
11890,
5034,
2934,
1896,
1769,
203,
203,
3639,
3455,
5093,
58,
273,
4336,
31,
203,
203,
3639,
8882,
273,
467,
9423,
42,
77,
24899,
16683,
2864,
1769,
203,
203,
3639,
1758,
328,
337,
969,
31,
203,
3639,
261,
80,
337,
969,
16,
269,
269,
283,
6397,
8924,
16,
269,
262,
273,
467,
17467,
338,
758,
1724,
12,
323,
1724,
8924,
13,
203,
5411,
263,
6011,
966,
24899,
6610,
1769,
203,
203,
3639,
2583,
12,
2867,
12,
80,
337,
969,
13,
422,
1758,
12,
17369,
10019,
203,
203,
3639,
609,
270,
461,
273,
389,
529,
31,
203,
203,
3639,
943,
27998,
5147,
273,
2130,
380,
404,
73,
29,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: GNU GPLv3
pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [////IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* ////IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20Upgradeable {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* ////IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.8.0;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Modifier to protect an initializer function from being invoked twice.
*/
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
pragma solidity ^0.8.0;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
*/
library StorageSlotUpgradeable {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
pragma solidity ^0.8.0;
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeaconUpgradeable {
/**
* @dev Must return an address that can be used as a delegate call target.
*
* {BeaconProxy} will check that this address is a contract.
*/
function implementation() external view returns (address);
}
pragma solidity ^0.8.2;
/**
* @dev This abstract contract provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
*
* _Available since v4.1._
*
* @custom:oz-upgrades-unsafe-allow delegatecall
*/
abstract contract ERC1967UpgradeUpgradeable is Initializable {
function __ERC1967Upgrade_init() internal initializer {
__ERC1967Upgrade_init_unchained();
}
function __ERC1967Upgrade_init_unchained() internal initializer {
}
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Emitted when the implementation is upgraded.
*/
event Upgraded(address indexed implementation);
/**
* @dev Returns the current implementation address.
*/
function _getImplementation() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 implementation slot.
*/
function _setImplementation(address newImplementation) private {
require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
/**
* @dev Perform implementation upgrade
*
* Emits an {Upgraded} event.
*/
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
/**
* @dev Perform implementation upgrade with additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCall(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
_functionDelegateCall(newImplementation, data);
}
}
/**
* @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCallSecure(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
_functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlotUpgradeable.BooleanSlot storage rollbackTesting = StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
_functionDelegateCall(
newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation)
);
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_upgradeTo(newImplementation);
}
}
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Emitted when the admin account has changed.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Returns the current admin.
*/
function _getAdmin() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 admin slot.
*/
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
/**
* @dev Changes the admin of the proxy.
*
* Emits an {AdminChanged} event.
*/
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
* This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
*/
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
/**
* @dev Emitted when the beacon is upgraded.
*/
event BeaconUpgraded(address indexed beacon);
/**
* @dev Returns the current beacon.
*/
function _getBeacon() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
}
/**
* @dev Stores a new beacon in the EIP1967 beacon slot.
*/
function _setBeacon(address newBeacon) private {
require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
/**
* @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
* not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
*
* Emits a {BeaconUpgraded} event.
*/
function _upgradeBeaconToAndCall(
address newBeacon,
bytes memory data,
bool forceCall
) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
_functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
}
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {
require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
}
uint256[50] private __gap;
}
pragma solidity ^0.8.0;
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20Upgradeable {
using AddressUpgradeable for address;
function safeTransfer(
IERC20Upgradeable token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20Upgradeable token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20Upgradeable token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20Upgradeable token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20Upgradeable token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
pragma solidity 0.8.4;
/**
* @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
* {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
*
* A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
* reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
* `UUPSUpgradeable` with a custom implementation of upgrades.
*
* The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
*
* _Available since v4.1._
*/
abstract contract UUPSUpgradeable is Initializable, ERC1967UpgradeUpgradeable {
function __UUPSUpgradeable_init() internal initializer {
__ERC1967Upgrade_init_unchained();
__UUPSUpgradeable_init_unchained();
}
function __UUPSUpgradeable_init_unchained() internal initializer {}
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
address private immutable __self = address(this);
/**
* @dev Check that the execution is being performed through a delegatecall call and that the execution context is
* a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
* for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
* function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
* fail.
*/
modifier onlyProxy() {
require(
address(this) != __self,
"Function must be called through delegatecall"
);
require(
_getImplementation() == __self,
"Function must be called through active proxy"
);
_;
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*/
function upgradeTo(address newImplementation) external virtual onlyProxy {
require(
newImplementation != address(0),
"Address should not be a zero address"
);
_authorizeUpgrade(newImplementation);
_upgradeToAndCallSecure(newImplementation, new bytes(0), false);
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
* encoded in `data`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*/
function upgradeToAndCall(address newImplementation, bytes memory data)
external
payable
virtual
onlyProxy
{
require(
newImplementation != address(0),
"Address should not be a zero address"
);
_authorizeUpgrade(newImplementation);
_upgradeToAndCallSecure(newImplementation, data, true);
}
/**
* @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
* {upgradeTo} and {upgradeToAndCall}.
*
* Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
*
* ```solidity
* function _authorizeUpgrade(address) internal override onlyOwner {}
* ```
*/
function _authorizeUpgrade(address newImplementation) internal virtual;
uint256[50] private __gap;
}
pragma solidity 0.8.4;
/// @title Vesting contract for creating token locks
/// @author Capx Team
/// @notice User can interact with the Vesting contract only through Master contract.
/// @dev This contract uses openzepplin Upgradable plugin. https://docs.openzeppelin.com/upgrades-plugins/1.x/
contract Vesting is Initializable, UUPSUpgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
uint256 internal constant DAY = 86400;
uint256 internal constant _ACTIVE = 2;
uint256 internal constant _INACTIVE = 1;
uint256 internal constant ADMIN_ACTIONS_DELAY = 3 * 86400;
uint256 public lockId;
uint256 internal _locked;
uint256 public newMasterDeadline;
address public masterController;
address public futureMasterController;
bool private masterSetFlag;
mapping(uint256 => Items) public lockedToken;
mapping(address => mapping(address => uint256)) public lockedTokenBalance;
struct Items {
address tokenAddress;
address withdrawalAddress;
uint256 tokenAmount;
uint256 unlockTime;
bool withdrawn;
}
event ProjectInfo(address indexed creator, address indexed tokenAddress);
event CreateVest(
uint256 vestID,
address indexed assetAddress,
address creator,
address userAddress,
uint256 userAmount,
uint256 unlockTime
);
event TransferLock(
uint256 vestID,
address userAddress,
address indexed wrappedTokenAddress,
address receiverAddress,
uint256 amount,
uint256 unlockTime
);
event Withdraw(
uint256 vestID,
address indexed userAddress,
uint256 amount,
address wrappedTokenAddress,
uint256 unlockTime
);
modifier noReentrant() {
require(_locked != _ACTIVE, "ReentrancyGuard: Re-Entrant call");
_locked = _ACTIVE;
_;
_locked = _INACTIVE;
}
function _authorizeUpgrade(address _newImplementation)
internal
override
onlyOwner
{}
function initialize() public initializer {
__Ownable_init();
_locked = _INACTIVE;
masterSetFlag = false;
}
function setMaster(address _master) external onlyOwner {
require(!masterSetFlag, "Master already set");
require(_master != address(0), "Invalid Address");
masterController = _master;
masterSetFlag = true;
}
function commitTransferMaster(address _newMaster) external onlyOwner {
require(_newMaster != address(0), "Invalid Input");
require(newMasterDeadline == 0, "Active Master transfer");
newMasterDeadline = block.timestamp + ADMIN_ACTIONS_DELAY;
futureMasterController = _newMaster;
}
function applyTransferMaster() external onlyOwner {
require(block.timestamp >= newMasterDeadline, "insufficient time");
require(newMasterDeadline != 0, "No Active master transfer");
newMasterDeadline = 0;
masterController = futureMasterController;
}
function revertMasterTransfer() external onlyOwner {
newMasterDeadline = 0;
}
/// @notice Helper function to transfer the corresponding token.
/// @dev Uses the IERC20Upgradable to transfer the asset from one user to another.
/// @param _tokenAddress The asset of which the transfer is to take place.
/// @param _from The address from which the asset is being transfered.
/// @param _to The address to whom the asset is being transfered.
/// @param _amount The quantity of the asset being transfered.
function _safeTransferERC20(
address _tokenAddress,
address _from,
address _to,
uint256 _amount
) internal {
// transfering ERC20 tokens from _projectOwner (msg.sender) to contract
if (_from == address(this)) {
IERC20Upgradeable(_tokenAddress).safeTransfer(_to, _amount);
} else {
IERC20Upgradeable(_tokenAddress).safeTransferFrom(
_from,
_to,
_amount
);
}
}
/// @notice Using this function a user can create locks of tokens.
/// @dev Each lock has a token assigned to it.
/// @param _tokenAddress The asset which is supposed to be locked.
/// @param _lockOwner Address passed by master which is trying to create the lock.
/// @param _amount The quantity of assets being locked.
/// @param _withdrawalAddress Address of users who can withdraw the locked tokens after vest time.
/// @param _distAmount The amount to be locked for each of the _withdrawalAddress.
/// @param _unlockTime Vest end time stamps of locks.
function lockTokens(
address _tokenAddress,
address _lockOwner,
uint256 _amount,
address[] calldata _withdrawalAddress,
uint256[] memory _distAmount,
uint256[] memory _unlockTime
) external virtual noReentrant {
require(msg.sender == masterController, "Not Authorized!");
require(_tokenAddress != address(0), "Invalid Token Address.");
require(
_amount > 0 &&
_withdrawalAddress.length != 0 &&
_withdrawalAddress.length <= 100,
"Invalid Inputs"
);
require(
_withdrawalAddress.length == _unlockTime.length &&
_unlockTime.length == _distAmount.length,
"Inconsistency in vesting details"
);
emit ProjectInfo(_lockOwner, _tokenAddress);
uint256 _sumAmount;
for (uint256 i = 0; i < _unlockTime.length; i++) {
_unlockTime[i] = (_unlockTime[i] / DAY) * DAY;
require(
_unlockTime[i] > ((block.timestamp / DAY) * DAY),
"Not a future Vest End Time"
);
require(
_distAmount[i] > 0 && _withdrawalAddress[i] != address(0),
"Invalid Locking Details"
);
lockId += 1;
//update balance in address
lockedTokenBalance[_tokenAddress][
_withdrawalAddress[i]
] += _distAmount[i];
lockedToken[lockId].tokenAddress = _tokenAddress;
lockedToken[lockId].withdrawalAddress = _withdrawalAddress[i];
lockedToken[lockId].tokenAmount = _distAmount[i];
lockedToken[lockId].unlockTime = _unlockTime[i];
lockedToken[lockId].withdrawn = false;
emit CreateVest(
lockId,
_tokenAddress,
_lockOwner,
_withdrawalAddress[i],
_distAmount[i],
_unlockTime[i]
);
_sumAmount += _distAmount[i];
}
require(_amount == _sumAmount, "Inconsistent amount of tokens");
}
/// @notice Using this function a user can transfer locks.
/// @dev New receiver address is set to existing lock.
/// @param _id lock ID to be transferred.
/// @param _receiverAddress Address to which the lock needs to be transferred.
/// @param _caller Address which called the controller address and owner of the lock.
function transferLocks(
uint256 _id,
address _receiverAddress,
address _caller
) external virtual noReentrant {
require(msg.sender == masterController, "Not Authorized!");
require(block.timestamp < lockedToken[_id].unlockTime);
require(
_caller == lockedToken[_id].withdrawalAddress,
"Not the lock owner"
);
lockedToken[_id].withdrawalAddress = _receiverAddress;
lockedTokenBalance[lockedToken[_id].tokenAddress][_caller] =
lockedTokenBalance[lockedToken[_id].tokenAddress][_caller] -
lockedToken[_id].tokenAmount;
lockedTokenBalance[lockedToken[_id].tokenAddress][_receiverAddress] =
lockedTokenBalance[lockedToken[_id].tokenAddress][
_receiverAddress
] +
lockedToken[_id].tokenAmount;
emit TransferLock(
_id,
_caller,
lockedToken[_id].tokenAddress,
_receiverAddress,
lockedToken[_id].tokenAmount,
lockedToken[_id].unlockTime
);
}
/// @notice Using this function a user can unlock the locked tokens.
/// @dev Unlocked tokens are sent to the user.
/// @param _id lock ID to be unlocked.
/// @param _caller Address which called the controller address to unlock tokens.
function withdrawTokens(uint256 _id, address _caller)
external
virtual
noReentrant
{
require(msg.sender == masterController, "Not Authorized!");
require(
block.timestamp >= lockedToken[_id].unlockTime,
"No withdrawl before time"
);
require(
_caller == lockedToken[_id].withdrawalAddress,
"only authorized withdrawl"
);
require(!lockedToken[_id].withdrawn, "already withdrawn");
_safeTransferERC20(
lockedToken[_id].tokenAddress,
address(this),
_caller,
lockedToken[_id].tokenAmount
);
lockedToken[_id].withdrawn = true;
lockedTokenBalance[lockedToken[_id].tokenAddress][_caller] =
lockedTokenBalance[lockedToken[_id].tokenAddress][_caller] -
lockedToken[_id].tokenAmount;
emit Withdraw(
_id,
_caller,
lockedToken[_id].tokenAmount,
lockedToken[_id].tokenAddress,
lockedToken[_id].unlockTime
);
}
} | * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by {upgradeTo} and {upgradeToAndCall}. Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. ```solidity function _authorizeUpgrade(address) internal override onlyOwner {} ```/ @title Vesting contract for creating token locks @author Capx Team @notice User can interact with the Vesting contract only through Master contract. @dev This contract uses openzepplin Upgradable plugin. https://docs.openzeppelin.com/upgrades-plugins/1.x/ | contract Vesting is Initializable, UUPSUpgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
uint256 internal constant DAY = 86400;
uint256 internal constant _ACTIVE = 2;
uint256 internal constant _INACTIVE = 1;
uint256 internal constant ADMIN_ACTIONS_DELAY = 3 * 86400;
uint256 public lockId;
uint256 internal _locked;
uint256 public newMasterDeadline;
address public masterController;
address public futureMasterController;
bool private masterSetFlag;
mapping(uint256 => Items) public lockedToken;
mapping(address => mapping(address => uint256)) public lockedTokenBalance;
function _authorizeUpgrade(address newImplementation) internal virtual;
uint256[50] private __gap;
}
pragma solidity 0.8.4;
struct Items {
address tokenAddress;
address withdrawalAddress;
uint256 tokenAmount;
uint256 unlockTime;
bool withdrawn;
}
event ProjectInfo(address indexed creator, address indexed tokenAddress);
event CreateVest(
uint256 vestID,
address indexed assetAddress,
address creator,
address userAddress,
uint256 userAmount,
uint256 unlockTime
);
event TransferLock(
uint256 vestID,
address userAddress,
address indexed wrappedTokenAddress,
address receiverAddress,
uint256 amount,
uint256 unlockTime
);
event Withdraw(
uint256 vestID,
address indexed userAddress,
uint256 amount,
address wrappedTokenAddress,
uint256 unlockTime
);
modifier noReentrant() {
require(_locked != _ACTIVE, "ReentrancyGuard: Re-Entrant call");
_locked = _ACTIVE;
_;
_locked = _INACTIVE;
}
{}
function _authorizeUpgrade(address _newImplementation)
internal
override
onlyOwner
function initialize() public initializer {
__Ownable_init();
_locked = _INACTIVE;
masterSetFlag = false;
}
function setMaster(address _master) external onlyOwner {
require(!masterSetFlag, "Master already set");
require(_master != address(0), "Invalid Address");
masterController = _master;
masterSetFlag = true;
}
function commitTransferMaster(address _newMaster) external onlyOwner {
require(_newMaster != address(0), "Invalid Input");
require(newMasterDeadline == 0, "Active Master transfer");
newMasterDeadline = block.timestamp + ADMIN_ACTIONS_DELAY;
futureMasterController = _newMaster;
}
function applyTransferMaster() external onlyOwner {
require(block.timestamp >= newMasterDeadline, "insufficient time");
require(newMasterDeadline != 0, "No Active master transfer");
newMasterDeadline = 0;
masterController = futureMasterController;
}
function revertMasterTransfer() external onlyOwner {
newMasterDeadline = 0;
}
function _safeTransferERC20(
address _tokenAddress,
address _from,
address _to,
uint256 _amount
) internal {
if (_from == address(this)) {
IERC20Upgradeable(_tokenAddress).safeTransfer(_to, _amount);
IERC20Upgradeable(_tokenAddress).safeTransferFrom(
_from,
_to,
_amount
);
}
}
function _safeTransferERC20(
address _tokenAddress,
address _from,
address _to,
uint256 _amount
) internal {
if (_from == address(this)) {
IERC20Upgradeable(_tokenAddress).safeTransfer(_to, _amount);
IERC20Upgradeable(_tokenAddress).safeTransferFrom(
_from,
_to,
_amount
);
}
}
} else {
function lockTokens(
address _tokenAddress,
address _lockOwner,
uint256 _amount,
address[] calldata _withdrawalAddress,
uint256[] memory _distAmount,
uint256[] memory _unlockTime
) external virtual noReentrant {
require(msg.sender == masterController, "Not Authorized!");
require(_tokenAddress != address(0), "Invalid Token Address.");
require(
_amount > 0 &&
_withdrawalAddress.length != 0 &&
_withdrawalAddress.length <= 100,
"Invalid Inputs"
);
require(
_withdrawalAddress.length == _unlockTime.length &&
_unlockTime.length == _distAmount.length,
"Inconsistency in vesting details"
);
emit ProjectInfo(_lockOwner, _tokenAddress);
uint256 _sumAmount;
for (uint256 i = 0; i < _unlockTime.length; i++) {
_unlockTime[i] = (_unlockTime[i] / DAY) * DAY;
require(
_unlockTime[i] > ((block.timestamp / DAY) * DAY),
"Not a future Vest End Time"
);
require(
_distAmount[i] > 0 && _withdrawalAddress[i] != address(0),
"Invalid Locking Details"
);
lockId += 1;
lockedTokenBalance[_tokenAddress][
_withdrawalAddress[i]
] += _distAmount[i];
lockedToken[lockId].tokenAddress = _tokenAddress;
lockedToken[lockId].withdrawalAddress = _withdrawalAddress[i];
lockedToken[lockId].tokenAmount = _distAmount[i];
lockedToken[lockId].unlockTime = _unlockTime[i];
lockedToken[lockId].withdrawn = false;
emit CreateVest(
lockId,
_tokenAddress,
_lockOwner,
_withdrawalAddress[i],
_distAmount[i],
_unlockTime[i]
);
_sumAmount += _distAmount[i];
}
require(_amount == _sumAmount, "Inconsistent amount of tokens");
}
function lockTokens(
address _tokenAddress,
address _lockOwner,
uint256 _amount,
address[] calldata _withdrawalAddress,
uint256[] memory _distAmount,
uint256[] memory _unlockTime
) external virtual noReentrant {
require(msg.sender == masterController, "Not Authorized!");
require(_tokenAddress != address(0), "Invalid Token Address.");
require(
_amount > 0 &&
_withdrawalAddress.length != 0 &&
_withdrawalAddress.length <= 100,
"Invalid Inputs"
);
require(
_withdrawalAddress.length == _unlockTime.length &&
_unlockTime.length == _distAmount.length,
"Inconsistency in vesting details"
);
emit ProjectInfo(_lockOwner, _tokenAddress);
uint256 _sumAmount;
for (uint256 i = 0; i < _unlockTime.length; i++) {
_unlockTime[i] = (_unlockTime[i] / DAY) * DAY;
require(
_unlockTime[i] > ((block.timestamp / DAY) * DAY),
"Not a future Vest End Time"
);
require(
_distAmount[i] > 0 && _withdrawalAddress[i] != address(0),
"Invalid Locking Details"
);
lockId += 1;
lockedTokenBalance[_tokenAddress][
_withdrawalAddress[i]
] += _distAmount[i];
lockedToken[lockId].tokenAddress = _tokenAddress;
lockedToken[lockId].withdrawalAddress = _withdrawalAddress[i];
lockedToken[lockId].tokenAmount = _distAmount[i];
lockedToken[lockId].unlockTime = _unlockTime[i];
lockedToken[lockId].withdrawn = false;
emit CreateVest(
lockId,
_tokenAddress,
_lockOwner,
_withdrawalAddress[i],
_distAmount[i],
_unlockTime[i]
);
_sumAmount += _distAmount[i];
}
require(_amount == _sumAmount, "Inconsistent amount of tokens");
}
function transferLocks(
uint256 _id,
address _receiverAddress,
address _caller
) external virtual noReentrant {
require(msg.sender == masterController, "Not Authorized!");
require(block.timestamp < lockedToken[_id].unlockTime);
require(
_caller == lockedToken[_id].withdrawalAddress,
"Not the lock owner"
);
lockedToken[_id].withdrawalAddress = _receiverAddress;
lockedTokenBalance[lockedToken[_id].tokenAddress][_caller] =
lockedTokenBalance[lockedToken[_id].tokenAddress][_caller] -
lockedToken[_id].tokenAmount;
lockedTokenBalance[lockedToken[_id].tokenAddress][_receiverAddress] =
lockedTokenBalance[lockedToken[_id].tokenAddress][
_receiverAddress
] +
lockedToken[_id].tokenAmount;
emit TransferLock(
_id,
_caller,
lockedToken[_id].tokenAddress,
_receiverAddress,
lockedToken[_id].tokenAmount,
lockedToken[_id].unlockTime
);
}
function withdrawTokens(uint256 _id, address _caller)
external
virtual
noReentrant
{
require(msg.sender == masterController, "Not Authorized!");
require(
block.timestamp >= lockedToken[_id].unlockTime,
"No withdrawl before time"
);
require(
_caller == lockedToken[_id].withdrawalAddress,
"only authorized withdrawl"
);
require(!lockedToken[_id].withdrawn, "already withdrawn");
_safeTransferERC20(
lockedToken[_id].tokenAddress,
address(this),
_caller,
lockedToken[_id].tokenAmount
);
lockedToken[_id].withdrawn = true;
lockedTokenBalance[lockedToken[_id].tokenAddress][_caller] =
lockedTokenBalance[lockedToken[_id].tokenAddress][_caller] -
lockedToken[_id].tokenAmount;
emit Withdraw(
_id,
_caller,
lockedToken[_id].tokenAmount,
lockedToken[_id].tokenAddress,
lockedToken[_id].unlockTime
);
}
} | 10,231,040 | [
1,
2083,
716,
1410,
15226,
1347,
1375,
3576,
18,
15330,
68,
353,
486,
10799,
358,
8400,
326,
6835,
18,
11782,
635,
288,
15097,
774,
97,
471,
288,
15097,
774,
1876,
1477,
5496,
24773,
1230,
16,
333,
445,
903,
999,
392,
15187,
30,
3860,
18,
4539,
63,
3860,
3325,
65,
9606,
4123,
487,
288,
5460,
429,
17,
3700,
5541,
5496,
31621,
30205,
560,
445,
389,
22488,
10784,
12,
2867,
13,
2713,
3849,
1338,
5541,
2618,
31621,
19,
225,
776,
10100,
6835,
364,
4979,
1147,
13046,
225,
11200,
92,
10434,
225,
2177,
848,
16592,
598,
326,
776,
10100,
6835,
1338,
3059,
13453,
6835,
18,
225,
1220,
6835,
4692,
1696,
94,
881,
412,
267,
1948,
9974,
429,
1909,
18,
2333,
2207,
8532,
18,
3190,
94,
881,
84,
292,
267,
18,
832,
19,
416,
13088,
17,
8057,
19,
21,
18,
92,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
776,
10100,
353,
10188,
6934,
16,
587,
3079,
55,
10784,
429,
16,
14223,
6914,
10784,
429,
288,
203,
565,
1450,
14060,
654,
39,
3462,
10784,
429,
364,
467,
654,
39,
3462,
10784,
429,
31,
203,
203,
565,
2254,
5034,
2713,
5381,
11579,
273,
21451,
31,
203,
565,
2254,
5034,
2713,
5381,
389,
13301,
273,
576,
31,
203,
565,
2254,
5034,
2713,
5381,
389,
706,
13301,
273,
404,
31,
203,
565,
2254,
5034,
2713,
5381,
25969,
67,
12249,
55,
67,
26101,
273,
890,
380,
21451,
31,
203,
203,
565,
2254,
5034,
1071,
2176,
548,
31,
203,
565,
2254,
5034,
2713,
389,
15091,
31,
203,
565,
2254,
5034,
1071,
394,
7786,
15839,
31,
203,
565,
1758,
1071,
4171,
2933,
31,
203,
565,
1758,
1071,
3563,
7786,
2933,
31,
203,
565,
1426,
3238,
4171,
694,
4678,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
10240,
13,
1071,
8586,
1345,
31,
203,
565,
2874,
12,
2867,
516,
2874,
12,
2867,
516,
2254,
5034,
3719,
1071,
8586,
1345,
13937,
31,
203,
203,
565,
445,
389,
22488,
10784,
12,
2867,
394,
13621,
13,
2713,
5024,
31,
203,
203,
565,
2254,
5034,
63,
3361,
65,
3238,
1001,
14048,
31,
203,
97,
203,
203,
203,
683,
9454,
18035,
560,
374,
18,
28,
18,
24,
31,
203,
203,
565,
1958,
10240,
288,
203,
3639,
1758,
1147,
1887,
31,
203,
3639,
1758,
598,
9446,
287,
1887,
31,
203,
3639,
2254,
5034,
1147,
6275,
31,
203,
3639,
2254,
5034,
7186,
950,
31,
203,
3639,
1426,
598,
9446,
82,
31,
203,
565,
289,
203,
2
]
|
./full_match/1/0xE8278fCd70B77d2Ab8e636351921Eed12D452F38/sources/contracts/MFA.sol | * @notice Adds a token attribute pair to a token's traits array. @dev Each tuple is a attribute type and value, eg. "color" and "red". @param _tokenId is the token to update. @param _traitType is the attribute type. @param _value is the attribute value./ | function pushTokenTrait(
uint256 _tokenId,
string memory _traitType,
string memory _value
) external onlyArtist notFrozen(_tokenId) {
Attribute memory newTrait = Attribute(_traitType, _value);
attributes[_tokenId].push(newTrait);
emit TokenUpdated(_tokenId);
}
| 8,336,417 | [
1,
3655,
279,
1147,
1566,
3082,
358,
279,
1147,
1807,
18370,
526,
18,
225,
8315,
3193,
353,
279,
1566,
618,
471,
460,
16,
9130,
18,
315,
3266,
6,
471,
315,
1118,
9654,
225,
389,
2316,
548,
353,
326,
1147,
358,
1089,
18,
225,
389,
22513,
559,
353,
326,
1566,
618,
18,
225,
389,
1132,
353,
326,
1566,
460,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
1817,
1345,
15525,
12,
203,
3639,
2254,
5034,
389,
2316,
548,
16,
203,
3639,
533,
3778,
389,
22513,
559,
16,
203,
3639,
533,
3778,
389,
1132,
203,
565,
262,
3903,
1338,
4411,
376,
486,
42,
9808,
24899,
2316,
548,
13,
288,
203,
3639,
3601,
3778,
394,
15525,
273,
3601,
24899,
22513,
559,
16,
389,
1132,
1769,
203,
3639,
1677,
63,
67,
2316,
548,
8009,
6206,
12,
2704,
15525,
1769,
203,
3639,
3626,
3155,
7381,
24899,
2316,
548,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/42/0x8266293e7427dCafBBBF1182bd5e78Bf1d7AA865/sources/b.sol | subtract from total `members`' votes with erc20 accounting
| totalSupply -= reaction; | 9,599,366 | [
1,
1717,
1575,
628,
2078,
1375,
7640,
11294,
19588,
598,
6445,
71,
3462,
2236,
310,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
5411,
2078,
3088,
1283,
3947,
12836,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0x28A3586D3Bdc2Dca11Ac131895F35059a0613C49/sources/Token.sol | Judging whether to distribute dividends in the local currency | function swapAndSendDividends(uint256 tokens) private {
if(currencyFlag){
AmountTokenRewardsFee = AmountTokenRewardsFee - tokens;
return;
}
if(usdtAddress == rewardsAddress){
swapTokensForUsdt(tokens,address(this));
swapTokensForRewards(tokens);
}
AmountTokenRewardsFee = AmountTokenRewardsFee - tokens;
}
| 15,713,013 | [
1,
46,
1100,
1998,
2856,
358,
25722,
3739,
350,
5839,
316,
326,
1191,
5462,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
7720,
1876,
3826,
7244,
350,
5839,
12,
11890,
5034,
2430,
13,
3238,
288,
203,
3639,
309,
12,
7095,
4678,
15329,
203,
1850,
16811,
1345,
17631,
14727,
14667,
273,
16811,
1345,
17631,
14727,
14667,
300,
2430,
31,
203,
1850,
327,
31,
203,
3639,
289,
203,
3639,
309,
12,
407,
7510,
1887,
422,
283,
6397,
1887,
15329,
203,
5411,
7720,
5157,
1290,
3477,
7510,
12,
7860,
16,
2867,
12,
2211,
10019,
203,
5411,
7720,
5157,
1290,
17631,
14727,
12,
7860,
1769,
203,
3639,
289,
203,
3639,
16811,
1345,
17631,
14727,
14667,
273,
16811,
1345,
17631,
14727,
14667,
300,
2430,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0xbB03246366ffb993A382c2F2E27F582Ae1cA2471/sources/contracts/Lottery/Lottery.sol | * @notice Called by the team to request a random number to a particular lottery. @param _lotteryId ID of the lottery the random number is for/ should fail if the lottery is completed (already called drawWinningNumbers and received a response) No random seed required (every ticket is a winner) | function requestRandomNumber(uint256 _lotteryId) external onlyAdmin {
LotteryInfo storage lottery = lotteryHistory[_lotteryId];
require(lottery.startTime > 0, "Invalid lottery id");
require(lottery.closeTime < block.timestamp, "Lottery is not closed");
Status status = lottery.status;
require(status != Status.Completed, "Lottery must not be completed");
if (lottery.numberOfTicketsSold <= lottery.numberOfEditions) {
lottery.status = Status.Completed;
lottery.status = Status.Closed;
randomGenerator.requestRandomWords(_lotteryId);
}
emit LotteryStatusChanged(_lotteryId, lottery.status);
}
| 17,051,474 | [
1,
8185,
635,
326,
5927,
358,
590,
279,
2744,
1300,
358,
279,
6826,
17417,
387,
93,
18,
225,
389,
23372,
387,
93,
548,
1599,
434,
326,
17417,
387,
93,
326,
2744,
1300,
353,
364,
19,
1410,
2321,
309,
326,
17417,
387,
93,
353,
5951,
261,
17583,
2566,
3724,
18049,
2093,
10072,
471,
5079,
279,
766,
13,
2631,
2744,
5009,
1931,
261,
20434,
9322,
353,
279,
5657,
1224,
13,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
590,
8529,
1854,
12,
11890,
5034,
389,
23372,
387,
93,
548,
13,
3903,
1338,
4446,
288,
203,
3639,
511,
352,
387,
93,
966,
2502,
17417,
387,
93,
273,
17417,
387,
93,
5623,
63,
67,
23372,
387,
93,
548,
15533,
203,
3639,
2583,
12,
23372,
387,
93,
18,
1937,
950,
405,
374,
16,
315,
1941,
17417,
387,
93,
612,
8863,
203,
3639,
2583,
12,
23372,
387,
93,
18,
4412,
950,
411,
1203,
18,
5508,
16,
315,
48,
352,
387,
93,
353,
486,
4375,
8863,
203,
3639,
2685,
1267,
273,
17417,
387,
93,
18,
2327,
31,
203,
3639,
2583,
12,
2327,
480,
2685,
18,
9556,
16,
315,
48,
352,
387,
93,
1297,
486,
506,
5951,
8863,
203,
3639,
309,
261,
23372,
387,
93,
18,
2696,
951,
6264,
2413,
55,
1673,
1648,
17417,
387,
93,
18,
2696,
951,
41,
1460,
87,
13,
288,
203,
5411,
17417,
387,
93,
18,
2327,
273,
2685,
18,
9556,
31,
203,
5411,
17417,
387,
93,
18,
2327,
273,
2685,
18,
7395,
31,
203,
5411,
2744,
3908,
18,
2293,
8529,
7363,
24899,
23372,
387,
93,
548,
1769,
203,
3639,
289,
203,
3639,
3626,
511,
352,
387,
93,
1482,
5033,
24899,
23372,
387,
93,
548,
16,
17417,
387,
93,
18,
2327,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol
// SPDX-License-Identifier: MIT
// pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* // importANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Dependency file: @openzeppelin/contracts/math/SafeMath.sol
// pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
/**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryDiv}.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
// Dependency file: @openzeppelin/contracts/utils/Address.sol
// pragma solidity >=0.6.2 <0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [// importANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* // importANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
// pragma solidity >=0.6.0 <0.8.0;
// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/math/SafeMath.sol";
// import "@openzeppelin/contracts/utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Dependency file: @openzeppelin/contracts/utils/Context.sol
// pragma solidity >=0.6.0 <0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/ERC20.sol
// pragma solidity >=0.6.0 <0.8.0;
// import "@openzeppelin/contracts/utils/Context.sol";
// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/math/SafeMath.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// Dependency file: @openzeppelin/contracts/token/ERC20/ERC20Burnable.sol
// pragma solidity >=0.6.0 <0.8.0;
// import "@openzeppelin/contracts/utils/Context.sol";
// import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
/**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
/**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
// Dependency file: @devprotocol/protocol/contracts/interface/IMarket.sol
// pragma solidity >=0.5.17;
interface IMarket {
function authenticate(
address _prop,
string calldata _args1,
string calldata _args2,
string calldata _args3,
string calldata _args4,
string calldata _args5
) external returns (bool);
function authenticateFromPropertyFactory(
address _prop,
address _author,
string calldata _args1,
string calldata _args2,
string calldata _args3,
string calldata _args4,
string calldata _args5
) external returns (bool);
function authenticatedCallback(address _property, bytes32 _idHash)
external
returns (address);
function deauthenticate(address _metrics) external;
function schema() external view returns (string memory);
function behavior() external view returns (address);
function issuedMetrics() external view returns (uint256);
function enabled() external view returns (bool);
function votingEndBlockNumber() external view returns (uint256);
function toEnable() external;
}
// Dependency file: @devprotocol/protocol/contracts/interface/IMarketBehavior.sol
// pragma solidity >=0.5.17;
interface IMarketBehavior {
function authenticate(
address _prop,
string calldata _args1,
string calldata _args2,
string calldata _args3,
string calldata _args4,
string calldata _args5,
address market,
address account
) external returns (bool);
function schema() external view returns (string memory);
function getId(address _metrics) external view returns (string memory);
function getMetrics(string calldata _id) external view returns (address);
}
// Dependency file: @devprotocol/protocol/contracts/interface/IProperty.sol
// pragma solidity >=0.5.17;
interface IProperty {
function author() external view returns (address);
function changeAuthor(address _nextAuthor) external;
function withdraw(address _sender, uint256 _value) external;
}
// Dependency file: @devprotocol/protocol/contracts/interface/IAddressConfig.sol
// pragma solidity >=0.5.17;
interface IAddressConfig {
function token() external view returns (address);
function allocator() external view returns (address);
function allocatorStorage() external view returns (address);
function withdraw() external view returns (address);
function withdrawStorage() external view returns (address);
function marketFactory() external view returns (address);
function marketGroup() external view returns (address);
function propertyFactory() external view returns (address);
function propertyGroup() external view returns (address);
function metricsGroup() external view returns (address);
function metricsFactory() external view returns (address);
function policy() external view returns (address);
function policyFactory() external view returns (address);
function policySet() external view returns (address);
function policyGroup() external view returns (address);
function lockup() external view returns (address);
function lockupStorage() external view returns (address);
function voteTimes() external view returns (address);
function voteTimesStorage() external view returns (address);
function voteCounter() external view returns (address);
function voteCounterStorage() external view returns (address);
function setAllocator(address _addr) external;
function setAllocatorStorage(address _addr) external;
function setWithdraw(address _addr) external;
function setWithdrawStorage(address _addr) external;
function setMarketFactory(address _addr) external;
function setMarketGroup(address _addr) external;
function setPropertyFactory(address _addr) external;
function setPropertyGroup(address _addr) external;
function setMetricsFactory(address _addr) external;
function setMetricsGroup(address _addr) external;
function setPolicyFactory(address _addr) external;
function setPolicyGroup(address _addr) external;
function setPolicySet(address _addr) external;
function setPolicy(address _addr) external;
function setToken(address _addr) external;
function setLockup(address _addr) external;
function setLockupStorage(address _addr) external;
function setVoteTimes(address _addr) external;
function setVoteTimesStorage(address _addr) external;
function setVoteCounter(address _addr) external;
function setVoteCounterStorage(address _addr) external;
}
// Dependency file: @devprotocol/protocol/contracts/interface/IDev.sol
// pragma solidity >=0.5.17;
interface IDev {
function deposit(address _to, uint256 _amount) external returns (bool);
function depositFrom(
address _from,
address _to,
uint256 _amount
) external returns (bool);
function fee(address _from, uint256 _amount) external returns (bool);
}
// Dependency file: @devprotocol/protocol/contracts/interface/ILockup.sol
// pragma solidity >=0.5.17;
interface ILockup {
function lockup(
address _from,
address _property,
uint256 _value
) external;
function update() external;
function withdraw(address _property, uint256 _amount) external;
function calculateCumulativeRewardPrices()
external
view
returns (
uint256 _reward,
uint256 _holders,
uint256 _interest
);
function calculateCumulativeHoldersRewardAmount(address _property)
external
view
returns (uint256);
function getPropertyValue(address _property)
external
view
returns (uint256);
function getAllValue() external view returns (uint256);
function getValue(address _property, address _sender)
external
view
returns (uint256);
function calculateWithdrawableInterestAmount(
address _property,
address _user
) external view returns (uint256);
}
// Dependency file: @openzeppelin/contracts/utils/EnumerableSet.sol
// pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// Dependency file: @openzeppelin/contracts/access/AccessControl.sol
// pragma solidity >=0.6.0 <0.8.0;
// import "@openzeppelin/contracts/utils/EnumerableSet.sol";
// import "@openzeppelin/contracts/utils/Address.sol";
// import "@openzeppelin/contracts/GSN/Context.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
// Dependency file: @devprotocol/util-contracts/contracts/access/IAdmin.sol
// pragma solidity >=0.7.6;
interface IAdmin {
function addAdmin(address admin) external;
function deleteAdmin(address admin) external;
function isAdmin(address account) external view returns (bool);
}
// Dependency file: @devprotocol/util-contracts/contracts/access/Admin.sol
// pragma solidity >=0.7.6;
// import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
// import {IAdmin} from "@devprotocol/util-contracts/contracts/access/IAdmin.sol";
abstract contract Admin is AccessControl, IAdmin {
constructor() {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
}
modifier onlyAdmin() {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "admin only.");
_;
}
function addAdmin(address admin) external virtual override onlyAdmin {
grantRole(DEFAULT_ADMIN_ROLE, admin);
}
function deleteAdmin(address admin) external virtual override onlyAdmin {
revokeRole(DEFAULT_ADMIN_ROLE, admin);
}
function isAdmin(address account) external view override returns (bool) {
return hasRole(DEFAULT_ADMIN_ROLE, account);
}
}
// Dependency file: @devprotocol/util-contracts/contracts/storage/EternalStorage.sol
// pragma solidity >=0.7.6;
/**
* Module for persisting states.
* Stores a map for `uint256`, `string`, `address`, `bytes32`, `bool`, and `int256` type with `bytes32` type as a key.
*/
contract EternalStorage {
address private currentOwner = msg.sender;
mapping(bytes32 => uint256) private uIntStorage;
mapping(bytes32 => string) private stringStorage;
mapping(bytes32 => address) private addressStorage;
mapping(bytes32 => bytes32) private bytesStorage;
mapping(bytes32 => bool) private boolStorage;
mapping(bytes32 => int256) private intStorage;
/**
* Modifiers to validate that only the owner can execute.
*/
modifier onlyCurrentOwner() {
require(msg.sender == currentOwner, "not current owner");
_;
}
/**
* Transfer the owner.
* Only the owner can execute this function.
*/
function changeOwner(address _newOwner) external {
require(msg.sender == currentOwner, "not current owner");
currentOwner = _newOwner;
}
// *** Getter Methods ***
/**
* Returns the value of the `uint256` type that mapped to the given key.
*/
function getUint(bytes32 _key) external view returns (uint256) {
return uIntStorage[_key];
}
/**
* Returns the value of the `string` type that mapped to the given key.
*/
function getString(bytes32 _key) external view returns (string memory) {
return stringStorage[_key];
}
/**
* Returns the value of the `address` type that mapped to the given key.
*/
function getAddress(bytes32 _key) external view returns (address) {
return addressStorage[_key];
}
/**
* Returns the value of the `bytes32` type that mapped to the given key.
*/
function getBytes(bytes32 _key) external view returns (bytes32) {
return bytesStorage[_key];
}
/**
* Returns the value of the `bool` type that mapped to the given key.
*/
function getBool(bytes32 _key) external view returns (bool) {
return boolStorage[_key];
}
/**
* Returns the value of the `int256` type that mapped to the given key.
*/
function getInt(bytes32 _key) external view returns (int256) {
return intStorage[_key];
}
// *** Setter Methods ***
/**
* Maps a value of `uint256` type to a given key.
* Only the owner can execute this function.
*/
function setUint(bytes32 _key, uint256 _value) external onlyCurrentOwner {
uIntStorage[_key] = _value;
}
/**
* Maps a value of `string` type to a given key.
* Only the owner can execute this function.
*/
function setString(bytes32 _key, string calldata _value)
external
onlyCurrentOwner
{
stringStorage[_key] = _value;
}
/**
* Maps a value of `address` type to a given key.
* Only the owner can execute this function.
*/
function setAddress(bytes32 _key, address _value)
external
onlyCurrentOwner
{
addressStorage[_key] = _value;
}
/**
* Maps a value of `bytes32` type to a given key.
* Only the owner can execute this function.
*/
function setBytes(bytes32 _key, bytes32 _value) external onlyCurrentOwner {
bytesStorage[_key] = _value;
}
/**
* Maps a value of `bool` type to a given key.
* Only the owner can execute this function.
*/
function setBool(bytes32 _key, bool _value) external onlyCurrentOwner {
boolStorage[_key] = _value;
}
/**
* Maps a value of `int256` type to a given key.
* Only the owner can execute this function.
*/
function setInt(bytes32 _key, int256 _value) external onlyCurrentOwner {
intStorage[_key] = _value;
}
// *** Delete Methods ***
/**
* Deletes the value of the `uint256` type that mapped to the given key.
* Only the owner can execute this function.
*/
function deleteUint(bytes32 _key) external onlyCurrentOwner {
delete uIntStorage[_key];
}
/**
* Deletes the value of the `string` type that mapped to the given key.
* Only the owner can execute this function.
*/
function deleteString(bytes32 _key) external onlyCurrentOwner {
delete stringStorage[_key];
}
/**
* Deletes the value of the `address` type that mapped to the given key.
* Only the owner can execute this function.
*/
function deleteAddress(bytes32 _key) external onlyCurrentOwner {
delete addressStorage[_key];
}
/**
* Deletes the value of the `bytes32` type that mapped to the given key.
* Only the owner can execute this function.
*/
function deleteBytes(bytes32 _key) external onlyCurrentOwner {
delete bytesStorage[_key];
}
/**
* Deletes the value of the `bool` type that mapped to the given key.
* Only the owner can execute this function.
*/
function deleteBool(bytes32 _key) external onlyCurrentOwner {
delete boolStorage[_key];
}
/**
* Deletes the value of the `int256` type that mapped to the given key.
* Only the owner can execute this function.
*/
function deleteInt(bytes32 _key) external onlyCurrentOwner {
delete intStorage[_key];
}
}
// Dependency file: @devprotocol/util-contracts/contracts/storage/IUsingStorage.sol
// pragma solidity >=0.7.6;
interface IUsingStorage {
// function addAdmin(address admin) external;
// function deleteAdmin(address admin) external;
// function isAdmin(address account) external view returns (bool);
function isStorageOwner(address account) external view returns (bool);
function addStorageOwner(address _storageOwner) external;
function deleteStorageOwner(address _storageOwner) external;
function getStorageAddress() external view returns (address);
function createStorage() external;
function setStorage(address _storageAddress) external;
function changeOwner(address newOwner) external;
}
// Dependency file: @devprotocol/util-contracts/contracts/storage/UsingStorage.sol
// pragma solidity >=0.7.6;
// import {Admin} from "@devprotocol/util-contracts/contracts/access/Admin.sol";
// import {EternalStorage} from "@devprotocol/util-contracts/contracts/storage/EternalStorage.sol";
// import {IUsingStorage} from "@devprotocol/util-contracts/contracts/storage/IUsingStorage.sol";
/**
* Module for contrast handling EternalStorage.
*/
contract UsingStorage is Admin, IUsingStorage {
address private _storage;
bytes32 public constant STORAGE_OWNER_ROLE =
keccak256("STORAGE_OWNER_ROLE");
constructor() {
_setRoleAdmin(STORAGE_OWNER_ROLE, DEFAULT_ADMIN_ROLE);
grantRole(STORAGE_OWNER_ROLE, _msgSender());
}
modifier onlyStoargeOwner() {
require(
hasRole(STORAGE_OWNER_ROLE, _msgSender()),
"storage owner only."
);
_;
}
function isStorageOwner(address account)
external
view
override
returns (bool)
{
return hasRole(STORAGE_OWNER_ROLE, account);
}
function addStorageOwner(address _storageOwner)
external
override
onlyAdmin
{
grantRole(STORAGE_OWNER_ROLE, _storageOwner);
}
function deleteStorageOwner(address _storageOwner)
external
override
onlyAdmin
{
revokeRole(STORAGE_OWNER_ROLE, _storageOwner);
}
/**
* Modifier to verify that EternalStorage is set.
*/
modifier hasStorage() {
require(_storage != address(0), "storage is not set");
_;
}
/**
* Returns the set EternalStorage instance.
*/
function eternalStorage()
internal
view
hasStorage
returns (EternalStorage)
{
return EternalStorage(_storage);
}
/**
* Returns the set EternalStorage address.
*/
function getStorageAddress()
external
view
override
hasStorage
returns (address)
{
return _storage;
}
/**
* Create a new EternalStorage contract.
* This function call will fail if the EternalStorage contract is already set.
* Also, only the storage owner can execute it.
*/
function createStorage() external override onlyStoargeOwner {
require(_storage == address(0), "storage is set");
EternalStorage tmp = new EternalStorage();
_storage = address(tmp);
}
/**
* Assigns the EternalStorage contract that has already been created.
* Only the storage owner can execute this function.
*/
function setStorage(address _storageAddress)
external
override
onlyStoargeOwner
{
_storage = _storageAddress;
}
/**
* Delegates the owner of the current EternalStorage contract.
* Only the storage owner can execute this function.
*/
function changeOwner(address newOwner) external override onlyStoargeOwner {
EternalStorage(_storage).changeOwner(newOwner);
}
}
// Dependency file: contracts/github/IncubatorStorage.sol
// pragma solidity 0.7.6;
// prettier-ignore
// import {UsingStorage} from "@devprotocol/util-contracts/contracts/storage/UsingStorage.sol";
contract IncubatorStorage is UsingStorage {
// StartPrice
function setStartPrice(string memory _githubRepository, uint256 _price)
internal
{
eternalStorage().setUint(getStartPriceKey(_githubRepository), _price);
}
function getStartPrice(string memory _githubRepository)
public
view
returns (uint256)
{
return eternalStorage().getUint(getStartPriceKey(_githubRepository));
}
function getStartPriceKey(string memory _githubRepository)
private
pure
returns (bytes32)
{
return keccak256(abi.encodePacked("_startPrice", _githubRepository));
}
// Staking
function setStaking(string memory _githubRepository, uint256 _staking)
internal
{
eternalStorage().setUint(getStakingKey(_githubRepository), _staking);
}
function getStaking(string memory _githubRepository)
public
view
returns (uint256)
{
return eternalStorage().getUint(getStakingKey(_githubRepository));
}
function getStakingKey(string memory _githubRepository)
private
pure
returns (bytes32)
{
return keccak256(abi.encodePacked("_staking", _githubRepository));
}
// Reward limit
function setRewardLimit(
string memory _githubRepository,
uint256 _rewardLimit
) internal {
eternalStorage().setUint(
getRewardLimitKey(_githubRepository),
_rewardLimit
);
}
function getRewardLimit(string memory _githubRepository)
public
view
returns (uint256)
{
return eternalStorage().getUint(getRewardLimitKey(_githubRepository));
}
function getRewardLimitKey(string memory _githubRepository)
private
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(_githubRepository, "_rewardLimit"));
}
// Reward lower limit
function setRewardLowerLimit(
string memory _githubRepository,
uint256 _rewardLowerLimit
) internal {
eternalStorage().setUint(
getRewardLowerLimitKey(_githubRepository),
_rewardLowerLimit
);
}
function getRewardLowerLimit(string memory _githubRepository)
public
view
returns (uint256)
{
return
eternalStorage().getUint(getRewardLowerLimitKey(_githubRepository));
}
function getRewardLowerLimitKey(string memory _githubRepository)
private
pure
returns (bytes32)
{
return
keccak256(abi.encodePacked(_githubRepository, "_rewardLowerLimit"));
}
// PropertyAddress
function setPropertyAddress(
string memory _githubRepository,
address _property
) internal {
eternalStorage().setAddress(
getPropertyAddressKey(_githubRepository),
_property
);
}
function getPropertyAddress(string memory _githubRepository)
public
view
returns (address)
{
return
eternalStorage().getAddress(
getPropertyAddressKey(_githubRepository)
);
}
function getPropertyAddressKey(string memory _githubRepository)
private
pure
returns (bytes32)
{
return
keccak256(abi.encodePacked("_propertyAddress", _githubRepository));
}
// AccountAddress
function setAccountAddress(address _property, address _account) internal {
eternalStorage().setAddress(getAccountAddressKey(_property), _account);
}
function getAccountAddress(address _property)
public
view
returns (address)
{
return eternalStorage().getAddress(getAccountAddressKey(_property));
}
function getAccountAddressKey(address _property)
private
pure
returns (bytes32)
{
return keccak256(abi.encodePacked("_accountAddress", _property));
}
// Market
function setMarketAddress(address _market) internal {
eternalStorage().setAddress(getMarketAddressKey(), _market);
}
function getMarketAddress() public view returns (address) {
return eternalStorage().getAddress(getMarketAddressKey());
}
function getMarketAddressKey() private pure returns (bytes32) {
return keccak256(abi.encodePacked("_marketAddress"));
}
// AddressConfig
function setAddressConfigAddress(address _addressConfig) internal {
eternalStorage().setAddress(
getAddressConfigAddressKey(),
_addressConfig
);
}
function getAddressConfigAddress() public view returns (address) {
return eternalStorage().getAddress(getAddressConfigAddressKey());
}
function getAddressConfigAddressKey() private pure returns (bytes32) {
return keccak256(abi.encodePacked("_addressConfig"));
}
// publicSignature
function setPublicSignature(
string memory _githubRepository,
string memory _publicSignature
) internal {
eternalStorage().setString(
getPublicSignatureKey(_githubRepository),
_publicSignature
);
}
function getPublicSignature(string memory _githubRepository)
public
view
returns (string memory)
{
return
eternalStorage().getString(
getPublicSignatureKey(_githubRepository)
);
}
function getPublicSignatureKey(string memory _githubRepository)
private
pure
returns (bytes32)
{
return
keccak256(abi.encodePacked("_publicSignature", _githubRepository));
}
// callbackKicker
function setCallbackKickerAddress(address _callbackKicker) internal {
eternalStorage().setAddress(
getCallbackKickerAddressKey(),
_callbackKicker
);
}
function getCallbackKickerAddress() public view returns (address) {
return eternalStorage().getAddress(getCallbackKickerAddressKey());
}
function getCallbackKickerAddressKey() private pure returns (bytes32) {
return keccak256(abi.encodePacked("_callbackKicker"));
}
}
// Root file: contracts/github/Incubator.sol
pragma solidity 0.7.6;
// import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
// import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
// prettier-ignore
// import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol";
// import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
// import {IMarket} from "@devprotocol/protocol/contracts/interface/IMarket.sol";
// prettier-ignore
// import {IMarketBehavior} from "@devprotocol/protocol/contracts/interface/IMarketBehavior.sol";
// prettier-ignore
// import {IProperty} from "@devprotocol/protocol/contracts/interface/IProperty.sol";
// prettier-ignore
// import {IAddressConfig} from "@devprotocol/protocol/contracts/interface/IAddressConfig.sol";
// import {IDev} from "@devprotocol/protocol/contracts/interface/IDev.sol";
// import {ILockup} from "@devprotocol/protocol/contracts/interface/ILockup.sol";
// prettier-ignore
// import {IncubatorStorage} from "contracts/github/IncubatorStorage.sol";
contract Incubator is IncubatorStorage {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Authenticate(
address indexed _sender,
address _market,
address _property,
string _githubRepository,
string _publicSignature
);
event Finish(
address indexed _property,
uint256 _status,
string _githubRepository,
uint256 _reward,
address _account,
uint256 _staking,
string _errorMessage
);
event Twitter(
string _githubRepository,
string _twitterId,
string _twitterPublicSignature,
string _githubPublicSignature
);
uint120 private constant BASIS_VALUE = 1000000000000000000;
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
constructor() {
_setRoleAdmin(OPERATOR_ROLE, DEFAULT_ADMIN_ROLE);
grantRole(OPERATOR_ROLE, _msgSender());
}
modifier onlyOperator {
require(isOperator(_msgSender()), "operator only.");
_;
}
function isOperator(address account) public view returns (bool) {
return hasRole(OPERATOR_ROLE, account);
}
function addOperator(address _operator) external onlyAdmin {
grantRole(OPERATOR_ROLE, _operator);
}
function deleteOperator(address _operator) external onlyAdmin {
revokeRole(OPERATOR_ROLE, _operator);
}
function start(
address _property,
string memory _githubRepository,
uint256 _staking,
uint256 _rewardLimit,
uint256 _rewardLowerLimit
) external onlyOperator {
require(_staking != 0, "staking is 0.");
uint256 lastPrice = getLastPrice();
setPropertyAddress(_githubRepository, _property);
setStartPrice(_githubRepository, lastPrice);
setStaking(_githubRepository, _staking);
_setRewardLimitAndLowerLimit(
_githubRepository,
_rewardLimit,
_rewardLowerLimit
);
}
function clearAccountAddress(address _property) external onlyOperator {
setAccountAddress(_property, address(0));
}
function authenticate(
string memory _githubRepository,
string memory _publicSignature
) external {
address property = getPropertyAddress(_githubRepository);
require(property != address(0), "illegal user.");
address account = getAccountAddress(property);
if (account != address(0)) {
require(account == _msgSender(), "authentication processed.");
}
address market = getMarketAddress();
bool result =
IMarket(market).authenticate(
property,
_githubRepository,
_publicSignature,
"",
"",
""
);
require(result, "failed to authenticate.");
setAccountAddress(property, _msgSender());
setPublicSignature(_githubRepository, _publicSignature);
emit Authenticate(
_msgSender(),
market,
property,
_githubRepository,
_publicSignature
);
}
function intermediateProcess(
string memory _githubRepository,
address _metrics,
string memory _twitterId,
string memory _twitterPublicSignature
) external {
address property = getPropertyAddress(_githubRepository);
require(property != address(0), "illegal repository.");
address account = getAccountAddress(property);
require(account != address(0), "no authenticate yet.");
require(account == msg.sender, "illegal user.");
address marketBehavior = IMarket(getMarketAddress()).behavior();
string memory id = IMarketBehavior(marketBehavior).getId(_metrics);
require(
keccak256(abi.encodePacked(id)) ==
keccak256(abi.encodePacked(_githubRepository)),
"illegal metrics."
);
string memory githubPublicSignatur =
getPublicSignature(_githubRepository);
emit Twitter(
_githubRepository,
_twitterId,
_twitterPublicSignature,
githubPublicSignatur
);
}
function finish(
string memory _githubRepository,
uint256 _status,
string memory _errorMessage
) external {
require(msg.sender == getCallbackKickerAddress(), "illegal access.");
address property = getPropertyAddress(_githubRepository);
address account = getAccountAddress(property);
uint256 reward = getReward(_githubRepository);
require(reward != 0, "reward is 0.");
uint256 staking = getStaking(_githubRepository);
if (_status != 0) {
emit Finish(
property,
_status,
_githubRepository,
reward,
account,
staking,
_errorMessage
);
return;
}
// transfer reward
address devToken = IAddressConfig(getAddressConfigAddress()).token();
IERC20 dev = IERC20(devToken);
dev.safeTransfer(account, reward);
// change property author
IProperty(property).changeAuthor(account);
IERC20 propertyInstance = IERC20(property);
uint256 balance = propertyInstance.balanceOf(address(this));
propertyInstance.safeTransfer(account, balance);
// event
emit Finish(
property,
_status,
_githubRepository,
reward,
account,
staking,
_errorMessage
);
}
function rescue(
address _token,
address _to,
uint256 _amount
) external onlyAdmin {
IERC20 token = IERC20(_token);
token.safeTransfer(_to, _amount);
}
function changeAuthor(address _token, address _author) external onlyAdmin {
IProperty(_token).changeAuthor(_author);
}
function getReward(string memory _githubRepository)
public
view
returns (uint256)
{
uint256 latestPrice = getLastPrice();
uint256 startPrice = getStartPrice(_githubRepository);
uint256 reward =
latestPrice.sub(startPrice).div(BASIS_VALUE).mul(
getStaking(_githubRepository)
);
uint256 rewardLimit = getRewardLimit(_githubRepository);
if (reward <= rewardLimit) {
return reward;
}
uint256 over = reward.sub(rewardLimit);
uint256 rewardLowerLimit = getRewardLowerLimit(_githubRepository);
if (rewardLimit < over) {
return rewardLowerLimit;
}
uint256 tmp = rewardLimit.sub(over);
return tmp <= rewardLowerLimit ? rewardLowerLimit : tmp;
}
function getLastPrice() private view returns (uint256) {
address lockup = IAddressConfig(getAddressConfigAddress()).lockup();
(, uint256 latestPrice, ) =
ILockup(lockup).calculateCumulativeRewardPrices();
return latestPrice;
}
//setter
function setMarket(address _market) external onlyAdmin {
require(_market != address(0), "address is 0.");
setMarketAddress(_market);
}
function setAddressConfig(address _addressConfig) external onlyAdmin {
require(_addressConfig != address(0), "address is 0.");
setAddressConfigAddress(_addressConfig);
}
function setCallbackKicker(address _callbackKicker) external onlyAdmin {
require(_callbackKicker != address(0), "address is 0.");
setCallbackKickerAddress(_callbackKicker);
}
function setRewardLimitAndLowerLimit(
string memory _githubRepository,
uint256 _rewardLimit,
uint256 _rewardLowerLimit
) external onlyOperator {
_setRewardLimitAndLowerLimit(
_githubRepository,
_rewardLimit,
_rewardLowerLimit
);
}
function _setRewardLimitAndLowerLimit(
string memory _githubRepository,
uint256 _rewardLimit,
uint256 _rewardLowerLimit
) private {
require(_rewardLimit != 0, "reward limit is 0.");
require(
_rewardLowerLimit <= _rewardLimit,
"limit is less than lower limit."
);
setRewardLimit(_githubRepository, _rewardLimit);
setRewardLowerLimit(_githubRepository, _rewardLowerLimit);
}
} | * @dev Extension of {ERC20} that allows token holders to destroy both their own tokens and those that they have an allowance for, in a way that can be recognized off-chain (via event analysis)./ | abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
| 342,310 | [
1,
3625,
434,
288,
654,
39,
3462,
97,
716,
5360,
1147,
366,
4665,
358,
5546,
3937,
3675,
4953,
2430,
471,
5348,
716,
2898,
1240,
392,
1699,
1359,
364,
16,
316,
279,
4031,
716,
848,
506,
16332,
3397,
17,
5639,
261,
21985,
871,
6285,
2934,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
17801,
6835,
4232,
39,
3462,
38,
321,
429,
353,
1772,
16,
4232,
39,
3462,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
203,
203,
203,
203,
565,
445,
18305,
12,
11890,
5034,
3844,
13,
1071,
5024,
288,
203,
3639,
389,
70,
321,
24899,
3576,
12021,
9334,
3844,
1769,
203,
565,
289,
203,
203,
565,
445,
18305,
1265,
12,
2867,
2236,
16,
2254,
5034,
3844,
13,
1071,
5024,
288,
203,
3639,
2254,
5034,
23850,
8905,
7009,
1359,
273,
1699,
1359,
12,
4631,
16,
389,
3576,
12021,
1435,
2934,
1717,
12,
8949,
16,
315,
654,
39,
3462,
30,
18305,
3844,
14399,
1699,
1359,
8863,
203,
203,
3639,
389,
12908,
537,
12,
4631,
16,
389,
3576,
12021,
9334,
23850,
8905,
7009,
1359,
1769,
203,
3639,
389,
70,
321,
12,
4631,
16,
3844,
1769,
203,
565,
289,
203,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/4/0x42A91727E808DBCD74eAC68C22aaA2aE004C70d9/sources/Depot.sol | * @notice Exchange dUSD for DET @param synthAmount The amount of synths the user wishes to exchange./ | function exchangeSynthsForDET(uint256 synthAmount)
external
rateNotInvalid(DET)
notPaused
returns (
)
{
return _exchangeSynthsForDET(synthAmount);
}
| 8,641,100 | [
1,
11688,
302,
3378,
40,
364,
463,
1584,
225,
6194,
451,
6275,
1021,
3844,
434,
6194,
451,
87,
326,
729,
14302,
281,
358,
7829,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
7829,
10503,
451,
28388,
40,
1584,
12,
11890,
5034,
6194,
451,
6275,
13,
203,
3639,
3903,
203,
3639,
4993,
1248,
1941,
12,
40,
1584,
13,
203,
3639,
486,
28590,
203,
3639,
1135,
261,
203,
3639,
262,
203,
565,
288,
203,
3639,
327,
389,
16641,
10503,
451,
28388,
40,
1584,
12,
11982,
451,
6275,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity 0.4.25;
import "./library/SafeMath.sol";
/// @dev GenesisOrganization interface
interface GenesisOrganization {
function existed(address caller) external returns (bool);
}
/// @dev Organization interface
interface Organization {
function canTransfer(address fromAddress, uint32 assetIndex) external returns(bool);
}
/// @title This is the registry center smart contract.
/// Every organization should register and get a unique organization ID before it can create assets on Asimov.
contract RegistryCenter {
/// delegate contract address
address constant delegateAddr = 0x630000000000000000000000000000000000000065;
/// initialized or not
bool private initialized;
/// last assigned organization id, auto incremental
uint32 lastOrganizationIdAssigned = 0;
/// @dev struct to keep organization information
struct OrganizationInfo {
/// organization id, name and contract address
uint32 organizationId;
string organizationName;
address organizationContract;
/// template used
string templateName;
/// organization status
/// once registered, the default status of an organization is 'active=true' and 'registered=true'
bool active;
bool registered;
/// the block height when organization status was lastly updated
uint blockHeight;
/// assets created by the organization
uint32[] assetIndexes;
}
/// @dev struct to keep template information
struct TemplateInfo {
/// template name, which is the primary key
string templateName;
/// template status
/// once registered, the default status of a template is 'active=true' and 'registered=true'
bool active;
bool registered;
/// the block height when template status was lastly updated
uint blockHeight;
// organizations created from this template
uint32[] organizationIds;
}
/// @dev struct to keep asset information
struct AssetInfo {
/// basic information
string name;
string symbol;
string description;
/// assetType
/// divisible = 0, indivisible = 1
uint32 assetType;
/// the organization id where this asset belongs to
uint32 organizationId;
/// the asset index inside the organization
uint32 assetIndex;
/// total amount issued on a divisible asset OR total count issued on an indivisible asset
uint totalIssued;
/// history of issued amount on a divisible asset OR voucherId on an indivisible asset
uint[] issuedHistory;
/// whether the asset is restricted for circulation
bool isRestricted;
// whether the asset is existed
bool existed;
}
// organizationName => bool
mapping (string => bool) organizationNameMap;
// organizationId => organizationInfo
mapping (uint32 => OrganizationInfo) organizationIdInfoMap;
// templateName => templateInfo
mapping (string => TemplateInfo) templateNameInfoMap;
// organizationAddress => organizationId
mapping (address => uint32) organizationAddressIdMap;
// assetId => assetInfo
mapping (uint64 => AssetInfo) assetIdInfoMap;
// Genesis organization reference
GenesisOrganization genesisOrganization;
/// black hole address to destory asset
address burnAddress;
/// close the organization
event CloseOrganizationEvent(address contractAddress);
function init() public {
require(!initialized, "it is not allowed to init more than once");
genesisOrganization = GenesisOrganization(0x630000000000000000000000000000000000000064);
burnAddress = 0x660000000000000000000000000000000000000000;
initialized = true;
}
/**
* @dev register an organization to Asimov, should only called by a contract
*
* @param organizationName organization name
* @param templateName template name
*/
function registerOrganization(string organizationName, string templateName) public returns(uint32) {
require(bytes(organizationName).length > 0, "invalid organization name");
require(bytes(templateName).length > 0 && bytes(templateName).length <= 128, "invalid template name");
require(!organizationNameMap[organizationName], "organization name already existed");
lastOrganizationIdAssigned = SafeMath.addUint32(lastOrganizationIdAssigned, 1);
OrganizationInfo storage orgInfo = organizationIdInfoMap[lastOrganizationIdAssigned];
orgInfo.organizationId = lastOrganizationIdAssigned;
orgInfo.organizationName = organizationName;
orgInfo.organizationContract = msg.sender;
orgInfo.templateName = templateName;
orgInfo.active = true;
orgInfo.registered = true;
orgInfo.blockHeight = block.number;
orgInfo.assetIndexes = new uint32[](0);
organizationNameMap[organizationName] = true;
organizationAddressIdMap[msg.sender] = lastOrganizationIdAssigned;
/// if the template does not exist yet, add it
TemplateInfo storage tInfo = templateNameInfoMap[templateName];
tInfo.organizationIds.push(lastOrganizationIdAssigned);
if (!tInfo.registered) {
tInfo.templateName = templateName;
tInfo.active = true;
tInfo.registered = true;
tInfo.blockHeight = block.number;
}
return lastOrganizationIdAssigned;
}
/**
* @dev update organization name
*
* @param organizationName new organization name
*/
function renameOrganization(string organizationName) public {
require(bytes(organizationName).length > 0, "invalid organization name");
require(!organizationNameMap[organizationName], "organization name already existed");
uint32 organizationId = organizationAddressIdMap[msg.sender];
require(organizationId > 0, "you have not registered organization");
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
if (orgInfo.registered) {
organizationNameMap[orgInfo.organizationName] = false;
orgInfo.organizationName = organizationName;
organizationNameMap[organizationName] = true;
}
}
/**
* @dev update organization status
*
* @param isActive the new status
*/
function updateOrganizationStatus(bool isActive) public {
uint32 organizationId = organizationAddressIdMap[msg.sender];
require(organizationId > 0, "you have not registered organization");
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
require(orgInfo.registered, "organization has not registered");
orgInfo.active = isActive;
orgInfo.blockHeight = block.number;
}
/**
* @dev close organization
*/
function closeOrganization() public {
uint32 organizationId = organizationAddressIdMap[msg.sender];
require(organizationId > 0, "you have not registered organization");
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
require(orgInfo.registered, "organization has not registered");
orgInfo.registered = false;
organizationNameMap[orgInfo.organizationName] = false;
/// this event is used by DAO
/// when DAO contract is self destructed, AScan needs a signal
emit CloseOrganizationEvent(msg.sender);
}
/**
* @dev deactivate a template
*
* @param templateName the template to deactivate
*/
function deactivateTemplate(string templateName) public {
require(genesisOrganization.existed(msg.sender), "not allowed to deactivate a template");
TemplateInfo storage tInfo = templateNameInfoMap[templateName];
require(tInfo.registered, "no such template");
tInfo.active = false;
tInfo.blockHeight = block.number;
}
/**
* @dev create an asset on Asimov chain, this function is called by 'flow.createAsset()' instruction
*
* @param organizationAddress organization address
* @param assetType divisible = 0, indivisible = 1
* @param assetIndex asset index in the organization
* @param amountOrVoucherId amount or voucherId of asset
* @param isRestricted restricted or not
* @return success or not
*/
function create(address organizationAddress, uint32 assetType, uint32 assetIndex, uint amountOrVoucherId, bool isRestricted)
public
returns (bool)
{
require(msg.sender == delegateAddr, "invalid caller");
require(0 == assetType || 1 == assetType, "invalid assetType");
uint32 organizationId = organizationAddressIdMap[organizationAddress];
require(organizationId > 0, "you have not registered organization");
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
if (!orgInfo.registered || !orgInfo.active) {
return false;
}
TemplateInfo storage tInfo = templateNameInfoMap[orgInfo.templateName];
if (!tInfo.active) {
return false;
}
uint64 assetId = generateAssetID(organizationId, assetIndex);
AssetInfo storage assetInfo = assetIdInfoMap[assetId];
if (assetInfo.existed) {
return false;
}
assetInfo.assetType = assetType;
assetInfo.assetIndex = assetIndex;
assetInfo.organizationId = organizationId;
assetInfo.isRestricted = isRestricted;
assetInfo.existed = true;
orgInfo.assetIndexes.push(assetIndex);
if (0 == getDivisibleBit(assetType)) {
assetInfo.totalIssued = amountOrVoucherId;
} else if (1 == getDivisibleBit(assetType)) {
assetInfo.totalIssued = 1;
}
assetInfo.issuedHistory.push(amountOrVoucherId);
return true;
}
/**
* @dev save asset basic information, should be called after `flow.createAsset()`
*
* @param assetIndex asset index in the organization
* @param name asset name
* @param symbol asset symbol
* @param description description of an asset
*/
function newAssetInfo(uint32 assetIndex, string name, string symbol, string description) public {
uint32 organizationId = organizationAddressIdMap[msg.sender];
require(organizationId > 0, "you have not registered organization");
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
require(orgInfo.registered, "organization hasn't registered");
require(orgInfo.active, "organization is inactive");
TemplateInfo storage tInfo = templateNameInfoMap[orgInfo.templateName];
require(tInfo.active, "template is inactive");
uint64 assetId = generateAssetID(organizationId, assetIndex);
AssetInfo storage assetInfo = assetIdInfoMap[assetId];
require(assetInfo.existed, "asset does not exist");
assetInfo.name = name;
assetInfo.symbol = symbol;
assetInfo.description = description;
}
/**
* @dev mint more asset, this function is called by 'flow.mintAsset()' instruction
*
* @param organizationAddress organization address
* @param assetIndex asset index in the organization
* @param amountOrVoucherId amount or voucherId of asset
*/
function mintAsset(address organizationAddress, uint32 assetIndex, uint amountOrVoucherId) public {
require(msg.sender == delegateAddr, "invalid caller");
uint32 organizationId = organizationAddressIdMap[organizationAddress];
require(organizationId > 0, "you have not registered organization");
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
require(orgInfo.registered, "organization hasn't registered");
require(orgInfo.active, "organization is inactive");
TemplateInfo storage tInfo = templateNameInfoMap[orgInfo.templateName];
require(tInfo.active, "template is inactive");
uint64 assetId = generateAssetID(organizationId, assetIndex);
AssetInfo storage assetInfo = assetIdInfoMap[assetId];
require(assetInfo.existed, "asset does not exist");
if (0 == getDivisibleBit(assetInfo.assetType)) {
assetInfo.totalIssued = SafeMath.add(assetInfo.totalIssued, amountOrVoucherId);
} else if (1 == getDivisibleBit(assetInfo.assetType)) {
assetInfo.totalIssued = SafeMath.add(assetInfo.totalIssued, 1);
}
assetInfo.issuedHistory.push(amountOrVoucherId);
}
/**
* @dev burn asset, assets can only be burned by the issuer
*/
function burnAsset() public payable {
require(msg.value > 0, "value must be bigger than 0");
uint32 organizationId = organizationAddressIdMap[msg.sender];
require(organizationId > 0, "you have not registered organization");
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
require(orgInfo.registered, "organization hasn't registered");
require(orgInfo.active, "organization is inactive");
TemplateInfo storage tInfo = templateNameInfoMap[orgInfo.templateName];
require(tInfo.active, "template is inactive");
AssetInfo storage assetInfo = assetIdInfoMap[uint64(bytes8(msg.assettype%2**64))];
require(assetInfo.existed, "asset does not exist");
require(organizationId == assetInfo.organizationId, "not authorized");
if (0 == getDivisibleBit(assetInfo.assetType)) {
require(assetInfo.totalIssued >= msg.value, "invalid amount");
assetInfo.totalIssued = SafeMath.sub(assetInfo.totalIssued, msg.value);
} else if (1 == getDivisibleBit(assetInfo.assetType)) {
require(assetInfo.totalIssued >= 1, "invalid call");
assetInfo.totalIssued = SafeMath.sub(assetInfo.totalIssued, 1);
}
burnAddress.transfer(msg.value, msg.assettype);
}
/**
* @dev get asset basic information by assetId
*
* @param organizationId the organization Id
* @param assetIndex asset index of an organization, which is maintained by the organization itself
* @return existed + name + symbol + description + total issued
*/
function getAssetInfoByAssetId(uint32 organizationId, uint32 assetIndex)
public
view
returns(bool, string, string, string, uint, uint[])
{
uint64 assetId = generateAssetID(organizationId, assetIndex);
AssetInfo storage assetInfo = assetIdInfoMap[assetId];
if (!assetInfo.existed) {
return (false, "", "", "", 0, new uint[](0));
}
return (true, assetInfo.name, assetInfo.symbol, assetInfo.description, assetInfo.totalIssued, assetInfo.issuedHistory);
}
/**
* @dev check whether the asset is restricted for circulation
*
* @param organizationId the organization Id
* @param assetIndex asset index of an organization, which is maintained by the organization itself
* @return yes or no
*/
function isRestrictedAsset(uint32 organizationId, uint32 assetIndex) public view returns(bool, bool) {
AssetInfo storage assetInfo = assetIdInfoMap[generateAssetID(organizationId, assetIndex)];
if (!assetInfo.existed) {
return (false, false);
}
return (true, assetInfo.isRestricted);
}
/**
* @dev remove circulation restriction of an asset
*
* @param assetIndex asset index of an organization, which is maintained by the organization itself
*/
function removeAssetRestriction(uint32 assetIndex) public {
uint32 organizationId = organizationAddressIdMap[msg.sender];
require(organizationId > 0, "you have not registered organization");
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
require(orgInfo.registered, "you have not registered organization");
require(orgInfo.active, "organization is inactive");
TemplateInfo storage tInfo = templateNameInfoMap[orgInfo.templateName];
require(tInfo.active, "template is inactive");
uint64 assetId = generateAssetID(organizationId, assetIndex);
AssetInfo storage assetInfo = assetIdInfoMap[assetId];
require(assetInfo.existed, "you have not create the asset");
assetInfo.isRestricted = false;
}
/**
* @dev get organization address by organization id
*
* @param organizationId the organization Id
* @param assetIndex asset index of an organization, which is maintained by the organization itself
* @return organization address
*/
function getOrganizationAddressById(uint32 organizationId, uint32 assetIndex)
public
view
returns(address)
{
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
if (!orgInfo.active) {
return 0x0;
}
uint64 assetId = generateAssetID(organizationId, assetIndex);
if (!assetIdInfoMap[assetId].existed) {
return 0x0;
}
TemplateInfo storage tInfo = templateNameInfoMap[orgInfo.templateName];
if (!tInfo.registered || !tInfo.active) {
return 0x0;
}
return orgInfo.organizationContract;
}
/**
* @dev get organization id
*
* @return (true/false + organization id)
*/
function getOrganizationId() public view returns(bool, uint32) {
uint32 organizationId = organizationAddressIdMap[msg.sender];
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
if (!orgInfo.registered) {
return (false, 0);
}
return (true, organizationId);
}
/**
* @dev find asset information by asset index
*
* @param assetIndex asset index of an organization, which is maintained by the organization itself
* @return (assetType + organizationId + existed)
*/
function findAsset(uint32 assetIndex) public view returns(uint32, uint32, bool) {
uint32 organizationId = organizationAddressIdMap[msg.sender];
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
if (!orgInfo.registered) {
return (0, 0, false);
}
uint64 assetId = generateAssetID(organizationId, assetIndex);
AssetInfo storage assetInfo = assetIdInfoMap[assetId];
if (!assetInfo.existed) {
return (0, 0, false);
}
return (assetInfo.assetType, assetInfo.organizationId, true);
}
/**
* @dev check whether the calling organization contract has registered
*
* @return yes or no
*/
function hasRegistered() public view returns(bool) {
uint32 organizationId = organizationAddressIdMap[msg.sender];
OrganizationInfo storage orgInfo = organizationIdInfoMap[organizationId];
return orgInfo.registered;
}
/**
* @dev batch get organization addresses by asset ids
*
* @return organization addresses
*/
function getOrganizationAddressesByAssets(uint64[] assetIds)
public
view
returns(address[])
{
uint length = assetIds.length;
if (length == 0) {
return new address[](0);
}
address[] memory addresses = new address[](length);
for (uint i = 0; i < length; i++) {
AssetInfo storage assetInfo = assetIdInfoMap[assetIds[i]];
if (assetInfo.existed) {
OrganizationInfo storage orgInfo = organizationIdInfoMap[assetInfo.organizationId];
addresses[i] = orgInfo.organizationContract;
}
}
return addresses;
}
/**
* @dev generate the asset id from organization id and asset index
*/
function generateAssetID(uint32 a, uint32 b) internal pure returns (uint64) {
return uint64(a) << 32 | uint64(b);
}
/**
* @dev internal method: get property of isDivisible from assetType
*/
function getDivisibleBit(uint32 assetType) internal pure returns(uint32) {
uint32 lastFourBits = assetType & 0xf;
return lastFourBits & 1;
}
}
| close the organization | event CloseOrganizationEvent(address contractAddress);
| 2,522,609 | [
1,
4412,
326,
6758,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
871,
3527,
8113,
1133,
12,
2867,
6835,
1887,
1769,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
facts сущ_предл_сущ language=Russian
{
arity=3
return=boolean
generic
}
#region Предлог_В
// -------------------------- ПРЕДЛОГ 'В' -----------------------------------
// для существительных с семантикой перемещения допускается присоединение 'в' с винительным падежом.
wordentry_set сущ_движения_для_в=
{
//существительное:доступ{}, // Как я могу получить доступ в учётную запись для ИП
существительное:игра{}, // Есть поле для игры в мини-футбол.
существительное:введение{}, // Я впустил его внутрь и произвел необходимые действия для его введения в должность второго пилота
существительное:направление{}, // Как получить направление в детский сад?
существительное:отдача{}, // Ему грозила отдача в психиатрическую лечебницу.
существительное:бегство{}, // Ее хватило для бегства в Швейцарию.
существительное:жалоба{}, // Так появилась жалоба в контрольно-ревизионное управление.
существительное:царапанье{}, // Но царапанье в дверь не прекратилось. (ЦАРАПАНЬЕ В ДВЕРЬ)
существительное:оглядка{}, // Правительство работает без оглядки на какое-то второе лицо.
существительное:внесение{}, // Создатель мельдония объяснил внесение препарата в список запрещенных
существительное:прием{}, // О приеме новых членов в комсомол говорил Саша Корнаков.
существительное:пострижение{}, // При пострижении в монашество переименовывают человека.
существительное:сошествие{}, // По сошествии в ад Он воскрес
существительное:вера{ одуш:неодуш }, // Вера в лен звучит в нем.
существительное:вызов{}, // Ждем вызова в Московский комитет партии.
существительное:игрок{}, // Игроки в демократию оказались одни и те же.
существительное:миграция{}, // Наблюдается активная миграция молодежи в различные уголки страны.
существительное:инвестирование{}, // Премьер Абхазии дорабатывает в Москве вопросы инвестирования в республику
существительное:вмешательство{}, // Предварительное расследование пока исключает вмешательство членов экипажа в работу системы пожаротушения.
существительное:выезд{}, // В случае выезда в другие регионы могут возникнуть проблемы.
существительное:сдача{}, // Сдача трубопровода в эксплуатацию переносится на более поздний срок.
существительное:вхождение{}, // Это было одним из условий вхождения Литвы в Евросоюз.
существительное:пропуск{}, // Надо оформлять пропуска в закрытую зону, изучать анкеты
существительное:наблюдение{}, // При любительских наблюдениях в бинокль или телескоп также следует использовать затемняющий светофильтр, помещённый перед объективом.
существительное:захват{},
существительное:взятие{},
существительное:путь{}, // Она описала путь в свою комнату. (ПУТЬ)
существительное:ОБРАЩЕНИЕ{}, // В 1229 году Немецкий Орден начал завоевание Пруссии для обращения в христианство прибалтийских язычников и подготовки немецкой колонизации. (ОБРАЩЕНИЕ)
существительное:ДОСТУП{}, // Одетым в перчатку правым кулаком он разбил окно, давшее ему доступ в комнату отдыха. (ДОСТУП)
существительное:рост{}, // рост производства в два раза (СУЩ+В+вин.доп.сокращение, увеличение)
существительное:падение{},
существительное:марш{}, // В Москве начинается «марш в защиту детей»
существительное:вторжение{}, // вторжение в Сирию не планируется (ВТОРЖЕНИЕ)
существительное:интервенция{}, // Британия отказалась от "гуманитарной интервенции" в Сирию
существительное:ПОПРАВКА{}, // Парламент Венгрии утвердил поправки в Конституцию, ослабляющие демократию в стране (ПОПРАВКА)
существительное:ИНВЕСТИЦИЯ{}, // Минфин предлагает освободить от налогов долгосрочные инвестиции физлиц в ценные бумаги (ИНВЕСТИЦИЯ)
существительное:ВВОД{}, // нарушают сроки оформления документации и ввода месторождений в эксплуатацию (ВВОД)
существительное:ВЫСТРЕЛ{}, // Он был убит выстрелом в затылок (ВЫСТРЕЛ)
существительное:УХОД{}, // Р.Кастро не исключает ухода в отставку по причине возраста (УХОД)
существительное:ВИЗА{}, // Россиянам усложнили получение виз в Тайвань (ВИЗА)
существительное:ДВЕРЬ{}, // передо мной была широко открытая дверь во двор (ДВЕРЬ)
существительное:удар{}, // нанес жертве решающий удар в живот
существительное:доставление{}, // В соответствии со своими должностными обязанностями милиционер комендантского отделения был обязан доложить о факте задержания и доставления курсанта в опорный пункт милиции
существительное:употребление{}, // употребление поддельных сухариков в пищу может повлечь пищевое отравление (УПОТРЕБЛЕНИЕ В)
существительное:РАНЕНИЕ{}, // судья , получившая огнестрельное ранение в живот (РАНЕНИЕ В вин)
существительное:ОТЧИСЛЕНИЕ{}, // из его зарплаты производятся отчисления в пользу дочери (ОТЧИСЛЕНИЯ В)
существительное:ТРУДОУСТРОЙСТВО{}, // письменное направление для трудоустройства в общество с ограниченной ответственностью (ТРУДОУСТРОЙСТВО В вин)
существительное:ОБЪЕДИНЕНИЕ{}, // получение политической власти и достижение сугубо политических целей не является основным мотивом объединения в данные группы и организации (ОБЪЕДИНЕНИЕ В вин)
существительное:капиталовложение{}, // Главная проблема Америки – низкий уровень капиталовложений в экономику!
существительное:звонок{}, // Экономьте на звонках в другие города и страны (ЗВОНОК В)
существительное:проход{}, // После выполнения финальной миссии можно найти проход в секретную зону последнего уровня. (ПРОХОД В)
существительное:попадание{}, // Минимальный зазор между крышкой и пиалой обеспечивает сохранение аромата чая и предотвращает попадание чаинок в питьевую чашку (ПОПАДАНИЕ В)
существительное:врата{}, // Каждый эпизод игрок начинает на футуристической военной базе, в которой присутствуют врата в альтернативную реальность (ВРАТА В)
существительное:выбор{}, // Когда проводятся выборы в сенат? (ВЫБОРЫ В)
существительное:внедрение{}, // внедрение достижений науки в производство (внедрение в)
существительное:возвращение{}, // возвращение блудного сына в отчий дом (возвращение в)
существительное:запуск{}, // запуск в экусплуатацию
существительное:постановка{}, // постановка судна в док
существительное:выход{}, // готовить для выхода в свет
существительное:проникновение{}, // воспрепятствовать проникновению в закрытое помещение
существительное:полёт{}, // полет в неизвестность
существительное:поступление{}, // Поступление в докторантуру университета
существительное:сбор{}, // Он давно кончил все свои сборы в дорогу.
существительное:кандидат{}, // Председатель предложил назвать кандидатов в комиссию.
существительное:вступление{}, // указ о вступлении в силу
существительное:изменение{}, // тенденция к изменению в худшую сторону
существительное:вклад{}, // присуждаться за весомый вклад в исследования рака
существительное:поездка{},
существительное:поход{},
существительное:путешествие{},
существительное:перемещение{},
существительное:визит{},
существительное:отправка{},
существительное:транспортировка{},
существительное:перевод{},
существительное:эмиграция{},
существительное:иммиграция{},
существительное:передача{},
существительное:дорога{}, // Я не знаю дороги в эту деревню.
существительное:поставка{}, // Россия сняла эмбарго на поставки оружия в Ливию
существительное:абонемент{}, // Я купил абонемент в оперу.
существительное:путевка{}, // Я достал путёвки в санаторий.
существительное:вход{}, // Я буду ждать вас у входа в музей.
существительное:оборот{}, // Этот мотор делает 600 оборотов в минуту.
существительное:превращение{}, // превращение куколки в бабочку
существительное:стук{}, // Раздаётся стук в дверь.
существительное:билет{}, // Мы купили билеты в цирк.
существительное:подача{}, // подача воды в определённые часы
существительное:явка{}, // явка в суд
существительное:переход{}, // переход в другую веру
существительное:доставка{}, // Другие говорили, что солдатам нельзя доверять доставку пленников в столицу.
существительное:приведение{} // приведение в исполнение
}
//ткань, ткань в полоску
//три урожая в год
// Путешествие в Москву
fact сущ_предл_сущ
{
if context { сущ_движения_для_в предлог:в{} существительное:*{ одуш:неодуш падеж:вин } }
then return true
}
// путешествие в Ixtlan
fact сущ_предл_сущ
{
if context { сущ_движения_для_в предлог:в{} @regex("[a-z]+[0-9]*") }
then return true
}
// Путешествие во Владивосток
fact сущ_предл_сущ
{
if context { сущ_движения_для_в{ } 'во' существительное:*{ одуш:неодуш падеж:вин } }
then return true
}
// работа в ночную смену
fact сущ_предл_сущ
{
if context { существительное:работа{} предлог:в{} существительное:смена{ падеж:вин } }
then return true
}
/*
// купи молока в магазине
fact сущ_предл_сущ
{
if context { существительное:молоко{} предлог:в{} существительное:магазин{} }
then return false
}
*/
// Предлог 'в' c предложным падежом всегда присоединяется к любым существительным
// Питательные элементы в ягодах легко усваиваются
// Кот в сапогах
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:в{} существительное:*{ одуш:неодуш падеж:предл } }
then return true
}
// Хлопнет калитка в саду
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:в{} существительное:*{ одуш:неодуш падеж:мест } }
then return true
}
// тёмные ночи в период майских дождей
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:в{} существительное:период{ падеж:вин } }
then return true
}
wordentry_set Сущ_В_Предл=существительное:{
убеждение, // ипохондрический бред — убеждение больного в наличии у него какого-то заболевания
работа, // Эти устройства неприспособлены к работе в жару
содержание, // Фрукты и ягоды особенно полезны организму благодаря содержанию в них витаминов, органических кислот и минеральных солей. (СОДЕРЖАНИЕ В)
специалист, // Эта программа была разработана при участии известных специалистов в области экономики. (СПЕЦИАЛИСТ В)
расчет, // Европа стала второй оффшорной зоной для расчетов в юанях
участие, // Приглашаем всех желающих принять участие в работе над статьями
штраф, // денежный штраф в размере 50 рублей
уверенность, // У меня нет уверенности в успехе.
успех, // успех в жизни
совещание, // совещание в верхах
понижение, // понижение в должности
дело // рассмотрение дела в последней инстанции
}
fact сущ_предл_сущ
{
if context { Сущ_В_Предл предлог:в{} *:*{ падеж:предл } }
then return true
}
wordentry_set Сущ_В_Им=существительное:{
кандидат
}
// Некоторые существительные могут прикреплять В + им.п.:
// кандидат в президенты
fact сущ_предл_сущ
{
if context { Сущ_В_Им предлог:в{} *:*{ падеж:им } }
then return true
}
// По умолчанию запретим связывание предлога В для существительных.
// То есть для всех остальных случаев предлог 'в' прикрепляется к глаголу:
// Питательные элементы в ягодах легко усваиваются
fact сущ_предл_сущ
{
if context { * предлог:в{} *:*{ падеж:предл } }
then return false,-4
}
fact сущ_предл_сущ
{
if context { * предлог:в{} * }
then return false,-6
}
#endregion Предлог_В
#region Предлог_ПОД
// ----------------------- ПРЕДЛОГ 'ПОД' ------------------------------
// снял запрет, чтобы разбирать:
// земля под ним горела
// ^^^^^^^
fact сущ_предл_сущ
{
if context { * предлог:под{} *:*{ падеж:твор } }
then return true
}
wordentry_set Сущ_ПОД_Вин=существительное:{
заключение // Решается вопрос об избрании ему меры пресечения в виде заключения под стражу.
}
fact сущ_предл_сущ
{
if context { Сущ_ПОД_Вин предлог:под{} *:*{ падеж:вин } }
then return true
}
fact сущ_предл_сущ
{
if context { * предлог:под{} *:*{ падеж:вин } }
then return false,-8
}
// По умолчанию запрещаем связывание сущ. с предлогом ПОД:
// мой руки с дезинфецирующим мылом под струёй тёплой воды
fact сущ_предл_сущ
{
if context { * предлог:под{} * }
then return false,-5
}
#endregion Предлог_ПОД
#region Предлог_ПРО
// ----------------------- ПРЕДЛОГ 'ПРО' ------------------------------
wordentry_set Сущ_Про_Вин=существительное:{
книга,// книга про пиратов
рассказ,
история,
роман,
фильм
}
// книга про пиратов
fact сущ_предл_сущ
{
if context { Сущ_Про_Вин предлог:про{} * }
then return true
}
// я рассказываю детям про пиратов
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:про{} * }
then return false,-10
}
#endregion Предлог_ПОД
#region Предлог_ОБ
// ----------------------- ПРЕДЛОГ 'ОБ' ------------------------------
wordentry_set Сущ_ОБ_Предл=существительное:{
учение, // В этике развил учение об атараксии.
воспоминание, // При воспоминании об этом Милли расхохоталась.
приказ, // неподчинение приказу об остановке судна
требование, // Требование правообладателя об удалении контента
резолюция, // Британский парламент отклонил правительственную резолюцию об основаниях для военной интервенции в Сирию
письмо, // Директор фирмы написала клиентам гарантийные письма об обязательстве возврата денег
данные, // НАТО не опубликует данные об атаках талибов в Афганистане (ДАННЫЕ)
мысль, // одна мысль об этом казалась мне чудовищной (МЫСЛЬ)
легенда, // А легенда об убийце органистки жила.
расследование, // Шесть европейских стран начинают расследование об отмывании нелегальных российских денег
законопроект, // Правительство одобрило законопроект об ускоренной постановке на налоговый учёт иностранцев или лиц без гражданства
МНЕНИЕ, // он выразил мнение об ожидаемом положительном эффекте от решения правительства докапитализировать банки (МНЕНИЕ ОБ)
РЕШЕНИЕ, // США приняли решение об ужесточении экономических санкций против Ирана (РЕШЕНИЕ ОБ)
ИНФОРМАЦИЯ, // получаю информацию обо всех игроках (ИНФОРМАЦИЯ ОБ)
ВОПРОС, // решается вопрос об избрании меры пресечения (ВОПРОС ОБ)
ДОГОВОР, // Россия пока не видит возможности для возобновления переговоров по Договору об обычных вооруженных силах в Европе (ДОГОВОР ОБ)
слух, // слух об их приближении летел впереди. (СЛУХ ОБ)
представление, // эти факты опровергают представления об устройстве Вселенной
размышление,
сообщение, // закидывать сообщениями об ошибках
рассказ, // крайне забавный рассказ об очень толстой кошке, мирно спящей на мягком кожаном диване
скорбь, // его скорбь об умершем животном вызывала острое сочувствие
история,
байка,
заявление, // заявление об отставке
дело, // Небольшое дело об убийстве
кодекс,
закон,
память, // Сохраните это на память обо мне.
упоминание // Поищи у коллеги упоминание об этом инциденте
}
fact сущ_предл_сущ
{
if context { Сущ_ОБ_Предл предлог:об{} *:*{ падеж:предл } }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_ОБ_Предл предлог:об{} @regex("[a-z]+[0-9]*") }
then return true
}
wordentry_set Сущ_ОБ_Вин=существительное:{
удар // раздался глухой удар клинка об пол.
}
fact сущ_предл_сущ
{
if context { Сущ_ОБ_Вин предлог:об{} *:*{ падеж:вин } }
then return true
}
// По умолчанию закроем связывание с предлогом ОБ
// Поищи упоминание у коллеги об этом инциденте
fact сущ_предл_сущ
{
if context { * предлог:об{} * }
then return false,-5
}
#endregion Предлог_ОБ
#region Предлог_С
// --------------------- ПРЕДЛОГ 'С' --------------------------------
// Обычно существительные нормально связываются с предлогом С, за исключением
// случаев, которые мы перечислим явно.
wordentry_set Запрет_Сущ_С=существительное:{
рука
}
fact сущ_предл_сущ
{
if context { Запрет_Сущ_С предлог:с{} * }
then return false
}
// По умолчанию запрещаем связывание сущ+С+вин.п.
// взгляд со стороны
fact сущ_предл_сущ
{
if context { *:*{} предлог:с{} *:*{ падеж:вин } }
then return false,-5
}
#endregion Предлог_С
#region Предлог_ПОСЛЕ
// ---------------------- ПРЕДЛОГ 'ПОСЛЕ' ---------------
// Пейзаж после битвы
fact сущ_предл_сущ
{
if context { существительное:пейзаж{} предлог:после{} *:*{ падеж:род } }
then return true
}
// Коль, купи молока после работы
fact сущ_предл_сущ
{
if context { * предлог:после{} * }
then return false,-5
}
#endregion Предлог_ПОСЛЕ
#region Предлог_ПРЕЖДЕ
// ---------------------- ПРЕДЛОГ 'ПРЕЖДЕ' ---------------
// Он принёс деньги прежде срока.
fact сущ_предл_сущ
{
if context { * предлог:прежде{} * }
then return false,-10
}
#endregion Предлог_ПРЕЖДЕ
#region Предлог_НА
// ---------------------- ПРЕДЛОГ 'НА' ---------------
// В редких случаях может быть связывание с НА+предл. падеж
wordentry_set Сущ_НА_Предл=существительное:{
заявление, // Заявление на материнский капитал оформляется в органах Пенсионного фонда по месту жительства.
проводы, // Ежегодно устраиваются торжественные проводы на пенсию.
пересадка, // В Москве предстоит пересадка на Сочи.
испытание, // Начинаются испытания стволовых клеток на людях
ПОЕДИНОК, // но была большая разница между поединком на рапирах и грязной поножовщиной без всяких правил
СОБЫТИЕ, // События на Кипре - сигнал большой опасности для России. (СОБЫТИЕ)
БЕЗОПАСНОСТЬ, // NASA усиливает безопасность на своих объектах (БЕЗОПАСНОСТЬ)
ЕЗДА, // снаряжение для езды на лошади (ЕЗДА)
наличие, // Доказательство наличия подповерхностного океана на Европе
проверка, // Чиновников отстранили от госзаказа после проверки на полиграфе
СЛУЖБА, // Служба на каникулах помешает учебному процессу (СЛУЖБА)
ПЯТНО, // Гигантское пятно на Солнце может привести к солнечным бурям (ПЯТНО)
ПОРЯДОК, // По мнению руководителя администрации города , продление сроков операции позволит , во-первых , навести порядок на рынке пиротехники (ПОРЯДОК НА предл)
ВОЗРОЖДЕНИЕ, // Общественная оборона — это возрождение идеи и практики земства на новом уровне развития русского общества (ВОЗРОЖДЕНИЕ НА)
АВАРИЯ, // Я очень сожалею , что произошла авария на одной из наших шахт (АВАРИЯ)
ПОЗИЦИЯ, // Политик пояснил , что различные страны продолжают осуществлять политику по укреплению своих позиций на Южном Кавказе (ПОЗИЦИЯ НА)
ГОЛОСОВАНИЕ, // Мне также довелось отслеживать процесс голосования на избирательном участке , расположенном на территории исправительной колонии (ГОЛОСОВАНИЕ НА предл)
ГИБЕЛЬ, // В Москве проводится проверка по факту гибели людей на железнодорожных путях (ГИБЕЛЬ НА)
давка, // Снегопад парализовал Москву и привёл к давке на некоторых станциях столичного метро (давка на)
интервенция, // Они даже рассматривали военные интервенции на Ближнем Востоке как способ что-то изменить (ИНТЕРВЕНЦИЯ НА предл)
покров, // Почему у человека редуцировался волосяной покров на теле? (ПОКРОВ НА)
убийство, // Он совершил убийство на почве ревности. (УБИЙСТВО НА ПОЧВЕ ...)
поездка, // Москвичей призывают воздержаться от поездок на личных автомобилях. (ПОЕЗДКА НА чем-то)
проблема, // Вслед за Западной Украиной проблемы на дорогах начались в восточных областях (проблема на)
поражение, // Лидер оппозиции Южной Кореи признал поражение на выборах. (ПОРАЖЕНИЕ НА)
ситуация, // Два министерства по-разному оценивают ситуацию на дорогах в западных областях (СИТУАЦИЯ НА)
опыт, // Опыты на крысах показали, что употребление сахара вызывает зависимость (ОПЫТ НА)
взрыв, // Взрыв на мясокомбинате в Мордовии (ВЗРЫВ НА)
катастрофа, // все помнят ту катастрофу на комбинате (КАТАСТРОФА НА)
операция, // Ему сделали операцию на сердце. (ОПЕРАЦИЯ НА)
торг, // возобновление торгов на бирже (торг на)
напряжение, // регулировать напряжением на базе
игра, // обучиться игре на скрипке
оглавление, // книга с картинками и оглавлением на иностранном языке
пожар, // пожар на фабрике огнетушителей
доля, // Банки увеличивают свою долю на рынке пластиковых карт.
присутствие, // Мелкие банки усиливают свое присутствие на рынке розничного кредитования.
обстановка, // Обстановка на дороге осложнена густым туманом.
трагедия, // трагедия на авиашоу
программирование, // прослушать учебный курс по программированию на функциональных языках
работа, // работа на стройках коммунизма
изображение, // четкое изображение на экране
случай, // С ним произошел несчастный случай на охоте
выступление, // Это было моё первое выступление на сцене.
применение, // Эта теория находит широкое применение на практике.
дело, // Дела на фронте поправляются.
преподавание, // в вузы можно вернуть преподавание на русском языке
исчезновение, // Исчезновение на 7-ой улице
трещина, // трещины на коже
торговля, // стандарт для торговли на лондонской бирже металла
сандалия // соломенные сандалии на верёвочной подошве
}
fact сущ_предл_сущ
{
if context { Сущ_НА_Предл предлог:на{} *:*{падеж:предл} }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_НА_Предл предлог:на{} *:*{падеж:мест} }
then return true
}
/*
// лицо на фотографии
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:на{} существительное:фотография{падеж:предл} }
then return true
}
*/
// просмотр на youtube
fact сущ_предл_сущ
{
if context { Сущ_НА_Предл предлог:на{} @regex("[a-z]+[0-9]*") }
then return true
}
/*
// крупная туманность на ночном небе
fact сущ_предл_сущ
{
if context { существительное:туманность{} предлог:на{} существительное:небо{падеж:предл} }
then return true
}
*/
wordentry_set Сущ_НА_Вин=существительное:{
ассигнование, // Из года в год увеличиваются ассигнования на оборону
опоздание, // Составлен рейтинг самых популярных причин опоздания на работу
гнев, // Ее внезапно охватил гнев на себя.
квота, // ПРАВИТЕЛЬСТВО УВЕЛИЧИТ КВОТЫ НА ИМПОРТ МЯСА (КВОТЫ НА ИМПОРТ МЯСА)
кандидат, // Нарушитель становится верным кандидатом на банкротство. (КАНДИДАТ НА ...)
документ, // Документы на товар у коммерсантов отсутствовали. (ДОКУМЕНТЫ НА ТОВАР)
путевка, // Сборная России выиграла путевку на Олимпиаду. (ПУТЕВКУ НА)
бремя, // Налоговое бремя на электроэнергетику не изменилось. (БРЕМЯ НА)
навал, // Мощный порог кончался навалом на скалы. (НАВАЛ НА)
предписание, // Были выданы предписания на устранение нарушений. (ПРЕДПИСАНИЕ НА УСТРАНЕНИЕ)
настрой, // твердый настрой на победу
намек, // В голосе слышался намек на иронию.
позыв, // При этом бывает внезапный позыв на мочу.
действие, // Теперь о действии Фосфорной кислоты на кости.
патент, // ФАС предложила игнорировать зарубежные патенты на лекарства
пародия, // Участники акции представили пародии на проекты здания небоскреба.
возвращение, // По возвращении на родину участвовал в разгроме Колчака.
дверь, // Дверь на сушу, кажется, открыта.
распоряжение, // Передайте в полки распоряжение на подготовку к перебазированию.
лицензия, // Большинство архангельских больниц не имеют лицензию на переливание крови
деление, // Система предусматривает деление маршрутной карты города на 62 лота.
воздействие, // Компании-разработчику предстоит ликвидировать последствия техногенных воздействий на окружающую среду.
отчисление, // Современное законодательство ликвидировало компенсационные отчисления на воспроизводство минерально-сырьевой базы.
приглашение, // Всем им были разосланы повестки с приглашением на заседание.
тендер, // Продолжается подготовка к проведению международного тендера на строительство АЭС.
выдвижение, // В Абазе завершилось выдвижение кандидатов на должность главы города
поправка, // При наблюдении звезд необходимо сделать поправку на аберрацию.
время, // У нас почти не было времени на осмотр дворца. (ВРЕМЯ)
обмен, // По этому пути огромные фургоны везли оружие и прочие товары, предназначенные для обмена на меха, шкуры, травы, слоновую кость и клыки (ОБМЕН)
вход, // Они стали входом на сцену (ВХОД)
экспорт, // Белоруссия увеличила свой экспорт в Россию
допуск,
ПЕРЕХОД, // Сирийская оппозиция сообщила о переходе на ее сторону генерала сирийской армии (ПЕРЕХОД)
ДОРОГА, // Прохожий спросил у меня дорогу на станцию (ДОРОГА)
ОХОТНИК, // У «Охотников на ведьм» появится продолжение (ОХОТНИК)
СУБСИДИЯ, // Д.Медведев утвердил распределение по регионам субсидий на медицинскую помощь (СУБСИДИЯ)
ПОДЪЕМ, // Подъём на гору продолжался два часа (ПОДЪЕМ)
мораторий, // Кремль снял мораторий на замену "слабых губернаторов"
план, // США раздражены планами Пакистана на иранский газ (ПЛАН)
отправка, // Японский робот Kibo готовится к отправке на борт Международной космической станции (ОТПРАВКА)
РЕАКЦИЯ, // стереотипная реакция организма на внешние раздражения (РЕАКЦИЯ)
ЖАЛОБА, // США заблокировали жалобу России на теракт в Сирии (ЖАЛОБА)
КУРС, // Курс нового Советского правительства на индустриализацию страны позволил создать мощную промышленную базу, необходимую для полного перевооружения Красной Армии (КУРС)
ПОСТАНОВКА, // Правительство одобрило законопроект об ускоренной постановке на налоговый учёт иностранцев или лиц без гражданства (ПОСТАНОВКА НА)
ТЕСТИРОВАНИЕ, // Законопроект о тестировании школьников Москвы на наркотики доработают (ТЕСТИРОВАНИЕ НА вин)
ПОСТАВКА, // для поставок на экспорт (ПОСТАВКА НА)
ПРЕТЕНДЕНТ, // Отбор претендентов на участие в конкурсе будет осуществлять конкурсная комиссия (ПРЕТЕНДЕНТ НА)
УХОд, // Виталию не следует думать об уходе на покой (УХОд НА вин)
ПОКУШЕНИЕ, // Выборы президента Армении могут перенести из-за покушения на кандидата (ПОКУШЕНИЕ НА)
ТАРИФ, // Окончательное решение о правомочности установления тарифа на услуги по передаче электрической энергии для этой организации планируется принять в декабре (ТАРИФ НА)
РАЗРЕШЕНИЕ, // для получения разрешений на право передвижения по заповедной акватории (РАЗРЕШЕНИЕ НА)
СТАВКА, // Парфюмеры делают ставку на провокации и психологию (СТАВКА НА)
СОГЛАСИЕ, // Нигер дал согласие на размещение американских беспилотников (СОГЛАСИЕ НА)
АТАКА, // Власть собирается бороться с атаками на сайт Кремля (АТАКА НА)
КОНТРАКТ, // Россия приостановила контракт на закупку итальянских бронемашин (КОНТРАКТ НА что-то)
ДАВЛЕНИЕ, // искусственно заниженные цены и понижающее давление на производство (ДАВЛЕНИЕ НА)
ЗАПРЕТ, // В Молдавии введен запрет на амнистию или помилование педофилов. (ЗАПРЕТ НА)
выезд, // Совет Федерации уточнил ответственность за выезд на встречную полосу. (ВЫЕЗД НА)
вторжение, // В агонии демон разрушает ад, и вторжение на Землю прекращается. (ВТОРЖЕНИЕ НА)
путь, // Он завернул к нам по пути на работу.
СООБРАЖЕНИЕ, // У меня есть свои соображения на этот счет (СООБРАЖЕНИЕ НА)
компромат, // С.Митрохин опубликовал компромат на думских подельников Гудкова (компромат на)
ограничение, // государство ввело ограничения на свободу перемещения (ограничение на)
вид, // затем открылся вид на море (вид на)
вывод, // вывод войск на позиции (вывод на)
продвижение, // мы замедлили продвижение на Восток (продвижение на)
нажатие, // откидывать нажатием на кнопку
воззрение, // Воззрения на природу человека
взгляд, // наши взгляды на жизнь слишком сильно различаются
очередь, // очередь на регистрацию
нападение, // нападение на члена НАТО
просмотр, // будем использовать просмотр на один шаг вперед
падение, // падение на асфальт
ссылка, // ссылка на источники
пошлина, // пошлины на импорт
акциз, // акциз на алкоголь
доклад, // Он готовит доклад на эту тему.
поездка, // Мы совершили поездку на север.
налёт, // совершить налёт на банк
указание, // это было указание на тайный смысл.
ответ, // Ученик дал правильный ответ на вопрос учителя.
шанс, // У этого села были большие шансы на процветание
право, // Они заработали трудом право на отдых.
избрание, // избрание на третий срок
затрата, // затраты на организацию спектакля
билет, // мы купили билеты на фильм
налог, // налог на предметы роскоши
охота, // Охота на хищниц
расход, // расходы на воспитание детей
явка, // явка на работу
неявка, // Она оправдала неявку на занятия болезнью.
цена, // подписная цена на газету
повышение, // Рабочие бастуют, требуя повышения зарплаты на двадцать процентов.
понижение,
спрос, // Растёт спрос на товары.
направление, // Самолёт взял направление на юг.
средство, // Средства на народное образование отпускает государство.
влияние, // Теория имеет очень сильное влияние на практику.
эмбарго, // Россия сняла эмбарго на поставки оружия в Ливию
транспортировка, // транспортировка на склад
диплом, // У него не было диплома на звание врача.
посягательство, // посягательство на свободу слова
выход
}
fact сущ_предл_сущ
{
if context { Сущ_НА_Вин предлог:на{} *:*{падеж:вин} }
then return true
}
// небо на горизонте
fact сущ_предл_сущ
{
if context { существительное:небо{} предлог:на{} 'горизонте'{падеж:предл} }
then return true
}
// работа на Google
fact сущ_предл_сущ
{
if context { Сущ_НА_Вин предлог:на{} @regex("[a-z]+[0-9]*") }
then return true
}
/*
// запрет связывания магазин+на, хотя для улиц он должен быть отключен:
// купи молока в магазине на оставшиеся деньги
fact сущ_предл_сущ
{
if context { существительное:магазин{} предлог:на{} * }
then return false
}
*/
fact сущ_предл_сущ
{
if context { * предлог:на{} *:*{ падеж:предл } }
then return false,-4
}
fact сущ_предл_сущ
{
if context { * предлог:на{} *:*{ падеж:мест } }
then return false,-4
}
fact сущ_предл_сущ
{
if context { * предлог:на{} *:*{ падеж:вин } }
then return false,-5
}
fact сущ_предл_сущ
{
if context { * предлог:на{} * }
then return false
}
#endregion Предлог_НА
#region Предлог_ИЗ_ПОД
// ------------- ПРЕДЛОГ 'ИЗ-ПОД' -----------------------
// Он выдвинул чемодан из-под кровати.
fact сущ_предл_сущ
{
if context { * предлог:из-под{} * }
then return false,-5
}
#endregion Предлог_ИЗ_ПОД
#region Предлог_В_СВЯЗИ_С
// ------------- ПРЕДЛОГ 'В СВЯЗИ С' -----------------------
fact сущ_предл_сущ
{
if context { * предлог:в связи с{} * }
then return false,-10
}
#endregion Предлог_В_СВЯЗИ_С
#region Предлог_ЗА
// ------------------ ПРЕДЛОГ 'ЗА' -------------------------------
// похороны за счёт города
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:за{} существительное:счет{ падеж:вин } }
then return true
}
wordentry_set Сущ_ЗА_Вин=существительное:{
долг, // В течение августа планируется закрыть долги за июнь полностью.
опасение, // Но у него есть серьезные опасения за ее жизнь.
борьба, // это борьба за существование!
тяжба, // МИД обеспокоен тяжбой американских лесбиянок за российского ребенка
контроль, // контроль за безопасностью
очередь, // очередь за едой
"матч-реванш", // матч-реванш за звание
бой,
премия, // премия за выслугу лет
борец, // последовательный борец за что-либо
убыток, // убыток компании за последние шесть месяцев
цена, // цена за килограмм
отъезд, // отъезд за границу
вердикт, // Вердикт за деньги
око, // Око за око
счет, // Я получил счёт за телефон.
ответственность, // Я снимаю с себя всякую ответственность за его поведение.
плата, // плата за ночное дежурство
оплата // оплата за неделю
}
fact сущ_предл_сущ
{
if context { Сущ_ЗА_Вин предлог:за{} *:*{ падеж:вин } }
then return true
}
wordentry_set Сущ_ЗА_Твор=существительное:{
контроль, // полномочия по контролю за выполнением лицензионных требований
надзор, // надзор за соблюдением
очередь, // Он встал в очередь за мясом.
Охотник // Охотники за разумом
}
fact сущ_предл_сущ
{
if context { Сущ_ЗА_Твор предлог:за{} *:*{ падеж:твор } }
then return true
}
fact сущ_предл_сущ
{
if context { * предлог:за{} * }
then return false,-4
}
#endregion Предлог_ЗА
#region Предлог_ПО
// ---------------------- ПРЕДЛОГ 'ПО' -------------------------------
// По умолчанию подавим связывание для этого предлога.
// Шла Женя по дороге и сосала сушки
wordentry_set Сущ_ПО_Дат={
существительное:тренинг{}, // Воронежские выпускники пройдут тренинг по сдаче единого государственного экзамена
существительное:чемпионат{}, // 18 августа пройдет чемпионат Мурманской области по уличным гонкам
существительное:собрат{}, // Секундой позже рухнули и два его собрата по несчастью.
существительное:товарищ{},
существительное:панихида{}, // Панихида по Эдварду Исабекяну состоится завтра, 21 августа.
существительное:льгота{}, // В Калмыкии льготы по оплате коммунальных услуг заменят денежными выплатами
существительное:кампания{}, // Кампания по отлову нелегальных мигрантов не может увенчаться успехом
существительное:переговоры{}, // После долгих переговоров по рации они получили приказ покинуть район аварии.
существительное:подъем{}, // подъем по склону
существительное:спуск{},
существительное:навигация{}, // Продвинутая навигация по файлам
существительное:ПУТЬ{}, // путь по равнине был очень долгим (ПУТЬ)
существительное:ПОСОЛ{ ОДУШ:ОДУШ }, // У Японии теперь есть посол по делам Арктики (ПОСОЛ)
существительное:МИНИСТЕРСТВО{}, // Генпрокуратура Украины утвердила обвинительное заключение по уголовному делу о закупках реанимобилей для Министерства по чрезвычайным ситуациям (МИНИСТЕРСТВО)
существительное:ПОХОД{}, // мы начали поход по горам (ПОХОД)
существительное:УЧЕБНИК{}, // Единый учебник по истории может появиться уже через год (УЧЕБНИК)
существительное:РЕШЕНИЕ{}, // Минтранс призывал ускорить решение по допуску на работу иностранных пилотов. (РЕШЕНИЕ ПО, + ДОПУСК НА)
существительное:авиаудар{},
существительное:передвижение{}, // для получения разрешений на право передвижения по заповедной акватории
существительное:завод{}, // В Кабардино-Балкарии ликвидирован подпольный завод по переработке нефти
существительное:ПОЗИЦИЯ{}, // Официальная позиция Берлина по энергетической политике с тех пор не изменилась (ПОЗИЦИЯ ПО)
существительное:ПОЛНОМОЧИЕ{}, // полномочия по контролю за выполнением лицензионных требований (ПОЛНОМОЧИЯ ПО)
существительное:СТАВКА{}, // в связи с мировым финансовым кризисом многие банки проводят политику увеличения процентных ставок по кредитам (СТАВКА ПО)
существительное:КОМИССИЯ{}, // будет создана двусторонняя межправительственная комиссия по делимитации и демаркации де-факто существующих границ (КОМИССИЯ ПО)
существительное: удар{}, // В результате удара снежной бури "Немо" по северо-востоку США
существительное:голосование{}, // В Египте начался второй раунд голосования по Конституции страны.
существительное:ностальгия{}, // Вы иронизируете о ностальгии по тем временем
существительное:регистрация{}, // Регистрация по месту жительства. (РЕГИСТРАЦИЯ ПО)
существительное:мастер{}, // Он большой мастер по части выбивания денег из начальства. (МАСТЕР ПО)
существительное:директор{ род:муж }, // заместитель директора по маркетинговой политике (ДИРЕКТОР ПО)
существительное:директор{ род:жен },
существительное:доставка{}, // Бесплатная доставка по Москве и России
существительное:подготовка{}, // У него слабая подготовка по литературе.
существительное:книга{}, // Книга по алгоритмам и структурам данных
существительное:экзамен{}, // сдать экзамен по английскому языку
существительное:курс{}, // слушать курс по русской литературе
существительное:шаг{}, // шаги по стимулированию продаж
существительное:помощь{}, // Нужна помошь по архитектурному решению
существительное:эксперт{}, // Как отличить эксперта по безопасности от тролля?
существительное:соревнование{}, // Он занял первое место в соревнованиях по плаванию.
существительное:сравнение{}, // сравнение двигателей по разным параметрам
существительное:мера{}, // меры по борьбе
существительное:соглашение{}, // мы пришли к соглашению по вопросу уборки квартиры
существительное:комитет{}, // смешанный комитет по науке и технике
существительное:подкомитет{},
существительное:операция{}, // операция по задержанию преступников удачно завершена
существительное:хождение{}, // Хождение по газонам запрещено.
существительное:инспектор{}, // инспектор по охране труда
существительное:вызов{}, // экстренный вызов по телефону
существительное:задача{}, // Она решила задачи по математике.
существительное:справочник{},
существительное:инструкция{},
существительное:рекомендация{},
существительное:специалист{}, // специалист по выведению бородавок
существительное:работа{}, // работа по благоустройству
существительное:движение{}, // движение по спирали
существительное:месяц{}, // пятый месяц по лунному календарю
существительное:лекция{}, // Профессор читает лекции по истории немецкой философии.
существительное:прогулка{}, // он соблазнил меня на прогулку по парку
существительное:путешествие{}, // он сопровождал ее в путешествии по Африке
существительное:перемещение{}, // перемещение по линии
существительное:оценка{}, // Папа разозлился на сына из-за плохих оценок по математике
существительное:экскурсия{}, // Закончился день экскурсией по Москве.
существительное:пособие{},
существительное:обвинение{} // Ему готовят обвинение по новому делу.
}
fact сущ_предл_сущ
{
if context { Сущ_ПО_Дат предлог:по{} *:*{ падеж:дат } }
then return true
}
// Справочник по Computer Science
fact сущ_предл_сущ
{
if context { Сущ_ПО_Дат предлог:по{} @regex("[a-z]+[0-9]*") }
then return true
}
fact сущ_предл_сущ
{
if context { * предлог:по{} * }
then return false,-5 // они - братья по оружию
}
#endregion Предлог_ПО
#region Предлог_О
// ----------------- ПРЕДЛОГ 'О' ----------------------
wordentry_set Сущ_о_вин=существительное:{
лязг, // нарушил его лязг железа о железо
рокот, // далеко внизу был слышен рокот прибоя о скалы. (РОКОТ О)
удар, // позади раздался грохот удара металла о дерево. (УДАР О)
скрежет, // послышался короткий глухой скрежет железа о камень. (СКРЕЖЕТ О)
стук, // позади раздался стук копий о палубу. (СТУК О)
показание // Подсудимый заявил, что дал показания о покушении под диктовку следователей
}
fact сущ_предл_сущ
{
if context { Сущ_о_вин предлог:о{} *:*{ падеж:вин } }
then return true
}
// Подавляем по умолчанию вариант О+вин.п.
fact сущ_предл_сущ
{
if context { * предлог:о{} *:*{ падеж:вин } }
then return false,-5
}
#endregion Предлог_О
#region Предлог_К
// ----------------- ПРЕДЛОГ 'К' ----------------------
wordentry_set Сущ_к_дат={
существительное:стремление{}, // Стремление к успеху есть всегда!
существительное:подключение{}, // Питание не требует подключения к сети
существительное:бонус{}, // Матрацы идут бонусом к комплектации.
существительное:агрессия{}, // Полностью отсутствует агрессия к людям.
существительное:аксессуар{}, // Аксессуары к платью продаются отдельно
существительное:сострадание{}, // В нем есть сострадание к ближнему.
существительное:нелюбовь{}, // любовь к Б. Ельцину не помешала сделать им такой выбор.
существительное:влечение{}, // Я почувствовал к нему непреодолимое влечение.
существительное:запчасть{},
существительное:пароль{},
существительное:ключик{},
существительное:ПОХОД{}, // Там они могли спланировать поход к любым тайным вратам на этом уровне. (ПОХОД)
существительное:ВОЗВРАТ{}, // Дума поддержала возврат к смешанной системе выборов (ВОЗВРАТ)
существительное:ПРЕМИЯ{}, // Премии к праздникам обложат страховыми взносами (ПРЕМИЯ)
существительное:МИССИЯ{}, // Россия и Европа подписали соглашение по двойной миссии к Марсу (МИССИЯ)
существительное:претензия{}, // У С.Собянина много претензий к работе коммунальщиков.
существительное:ПРЕЛЮДИЯ{}, // Но это было лишь прелюдией к главному событию, потому что вскоре эта звезда превратится в сверхновую (ПРЕЛЮДИЯ)
существительное:АППЕТИТ{}, // у тебя аппетит к жизни пропал (АППЕТИТ)
существительное:неравнодушие{}, // Его подвело неравнодушие к прекрасному полу.
существительное:равнодушие{},
существительное:отвращение{}, // постепенно его охватило отвращение к себе
существительное:ПРЕНЕБРЕЖЕНИЕ{}, // Хунвэйбинские группировки отличались крайним пренебрежением к традиционной культуре (ПРЕНЕБРЕЖЕНИЕ К)
существительное:ПОДВОЗ{}, // решается вопрос с подвозом воды к объектам , имеющим социально-экономическое значение (ПОДВОЗ К)
существительное:ПОДСКАЗКА{}, // подсказка к ответу кроется как раз в новом распределении руководящих обязанностей (ПОДСКАЗКА К)
существительное:ГОТОВНОСТЬ{}, // Представитель сирийской оппозиции заявил о готовности к переговорам с властями (ГОТОВНОСТЬ К)
существительное:ПОДОЗРИТЕЛЬНОСТЬ{}, // разжигая подозрительность к Западу (ПОДОЗРИТЕЛЬНОСТЬ К)
существительное:ПРИВЛЕЧЕНИЕ{}, // решается вопрос о привлечении к дисциплинарной ответственности командира воинской части (ПРИВЛЕЧЕНИЕ К)
существительное:ПРИВЯЗКА{}, // резиденты могут с этого момента осуществлять планировку своих объектов с привязкой к местности (ПРИВЯЗКА К)
существительное:ВОПРОС{}, // возникли новые уточняющие вопросы к армянским сторонам (ВОПРОС К)
существительное:ПРЕАМБУЛА{}, // В преамбуле к проекту кодекса отмечается (ПРЕАМБУЛА К)
существительное:УСТОЙЧИВОСТЬ{}, // Поэтому для повышения устойчивости организма к простудным заболеваниям необходимо использовать препараты неспецифической профилактики (УСТОЙЧИВОСТЬ)
существительное:приложение{},
существительное:видеоприложение{},
существительное:причастность{}, // Н.Цискаридзе ответил на обвинения в причастности к нападению на С.Филина
существительное:СПОСОБНОСТЬ{}, // Это согласуется с гипотезой о том, что заразительная зевота отражает способность к эмпатии (СПОСОБНОСТЬ К)
существительное:ПРИНУЖДЕНИЕ{}, // правительство страны не принимало мер по принуждению банков к увеличению капитала, и не давало возможности иностранным инвесторам поглощать японские банки (ПРИНУЖДЕНИЕ К)
существительное:ПРОХОД{}, // открылся проход к клетке (ПРОХОД К)
существительное:ЧУВСТВИТЕЛЬНОСТЬ{}, // Обладает высокой чувствительностью к удару (ЧУВСТВИТЕЛЬНОСТЬ К)
существительное:ПРИНАДЛЕЖНОСТЬ{}, // Современное состояние климата Земли характеризуется принадлежностью к одной из межледниковых эпох голоцена (ПРИНАДЛЕЖНОСТЬ К)
существительное:НЕСПОСОБНОСТЬ{}, // В сложившейся обстановке правительство и сам царь проявили неспособность к быстрым и решительным действиям (НЕСПОСОБНОСТЬ К)
существительное:КРИТИКА{}, // Затухание бреда — появление критики к бредовым идеям (КРИТИКА К)
существительное:ПРИПРАВА{}, // Молодые листья укропа используют как вкусовую ароматическую приправу к горячим и холодным блюдам (ПРИПРАВА К)
существительное:ДВИЖЕНИЕ{}, // мы продолжали наше движение к дому. (ДВИЖЕНИЕ К)
существительное:ВОЗВРАЩЕНИЕ{}, // возвращение к власти будет происходить постепенно. (ВОЗВРАЩЕНИЕ К)
существительное:средство{}, // оставшись без средств с существованию, люди зверели (СРЕДСТВА К)
существительное:шаг{}, // мастер сделал шаг к ней. (ШАГ К)
существительное:чувство{}, // мои чувства к ней
существительное:ДОСТУП{}, // только доступ к ним закрыт. (ДОСТУП К)
существительное:УВАЖЕНИЕ{}, // а где наше уважение к смерти? (УВАЖЕНИЕ К)
существительное:поворот{}, // где поворот к мастерской? (поворот к)
существительное:ЖАЛОСТЬ{}, // Ольга вдруг ощутила жалость к этому человеку. (ЖАЛОСТЬ К)
существительное:спуск{}, // прямо перед ними начинался спуск к ручью.
существительное:дорога{}, // Бережливость - верная дорога к благосостоянию.
существительное:прием{}, // Запишите меня на завтрашний приём к доктору.
существительное:ненависть{}, // он испытывает давнюю ненависть к паукам
существительное:привязанность{}, // питать привязанность к алкоголю
существительное:склонность{}, // проявлять склонность к немотивированной агрессии
существительное:поездка{}, // крайне утомительная поездка к дедушке, живущему в деревне
существительное:применимость{}, // разработчики доказали на практике применимость данного подхода к обсчету сцен
существительное:интерес{}, // Интерес к теориям учёного не угасает и в наши дни.
существительное:доверие{}, // Я не питаю большого доверия к её талантам.
существительное:руководство{}, // План - руководство к действию.
существительное:подход{}, // Это правильный подход к решению вопроса.
существительное:повод{},
существительное:сигнал{}, // Статья послужила сигналом к дискуссии.
существительное:переход{}, // постепенный переход к рынку
существительное:безразличие{}, // безразличие к боли
существительное:призыв{}, // Он закончил речь призывом к борьбе.
существительное:сожаление{}, // Я чувствовал сожаление к нему.
существительное:подарок{}, // Я купил подарок к празднику.
существительное:приезд{}, // Сам его приезд к сыну означает примирение.
существительное:ключ{}, // ключ к шифру
существительное:описание{}, // инструмент для создания описания к лоту
существительное:отношение{}, // философское отношение к жизни
существительное:отход{}, // отход ко сну
существительное:путь{}, // На пути к смерти
существительное:тенденция{}, // тенденция к повышению цен
существительное:направление{}, // Мы пошли вместе по направлению к городу.
существительное:любовь{ одуш:неодуш }, // Она сделала это из любви к детям.
существительное:визит{}, // визит к минотавру
существительное:обращение{}, // обращение к президенту
существительное:подготовка{}, // подготовка к экзамену
существительное:путешествие{} // Путешествие к центру Земли
}
fact сущ_предл_сущ
{
if context { Сущ_к_дат предлог:к{} *:*{ падеж:дат } }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_к_дат предлог:к{} @regex("[a-z]+[0-9]*") }
then return true
}
// Подавляем по умолчанию вариант К+дат.п.
// Она отвела собеседника к окну.
fact сущ_предл_сущ
{
if context { * предлог:к{} *:*{ падеж:дат } }
then return false,-5
}
#endregion Предлог_К
#region Предлог_ЧЕРЕЗ_СКВОЗЬ
// ----------------- ПРЕДЛОГ 'ЧЕРЕЗ' ----------------------
wordentry_set Сущ_через_вин={
существительное:полет{}, // полет к звездам сквозь иные измерения!
существительное:прохождение{}, // Украина пытается договориться с Турцией о прохождении танкеров с газом через Босфор
существительное:ДОРОГА{}, // по дороге через лес (ДОРОГА ЧЕРЕЗ)
существительное:трансляция{}, // руководство Ассоциации заключило договоренность с некоторыми регионами России о трансляции этого канала через местные кабельные сети
существительное:ПУТЬ{}, // это единственный путь через эти горы (ПУТЬ ЧЕРЕЗ)
существительное:ДВИЖЕНИЕ{}, // это ощущение от движения робота через болото (ДВИЖЕНИЕ ЧЕРЕЗ)
существительное:проникновение{},
существительное:транспортировка{}, // транспортировка через тоннель
существительное:смерть{}, // смерть через повешение
существительное:казнь{}, // казнь через повешение
существительное:проезд{}, // проезд через тоннель
существительное:проход{}, // проход через звездные врата
существительное:перемещение{}, // перемещение через червоточину
существительное:перелет{}, // перелет через атлантику
существительное:пролет{} // пролет через врата
}
fact сущ_предл_сущ
{
if context { Сущ_через_вин предлог:через{} *:*{ падеж:вин } }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_через_вин предлог:сквозь{} *:*{ падеж:вин } }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_через_вин предлог:через{} @regex("[a-z]+[0-9]*") }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_через_вин предлог:сквозь{} @regex("[a-z]+[0-9]*") }
then return true
}
// ребенок через два дня вернулся
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:через{} *:*{} }
then return false,-10
}
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:сквозь{} *:*{} }
then return false,-10
}
// Подавляем по умолчанию вариант ЧЕРЕЗ+вин.п.
// Она тянула холодный лимонад через соломинку.
fact сущ_предл_сущ
{
if context { * предлог:через{} *:*{ падеж:вин } }
then return false,-5
}
fact сущ_предл_сущ
{
if context { * предлог:сквозь{} *:*{ падеж:вин } }
then return false,-5
}
#endregion Предлог_ЧЕРЕЗ_СКВОЗЬ
#region Предлог_СКВОЗЬ
// ----------------- ПРЕДЛОГ 'СКВОЗЬ' ----------------------
wordentry_set Сущ_сквозь_вин={
существительное:транспортировка{}, // транспортировка сквозь тоннель
существительное:проникновение{}, // проникновение сквозь барьер
существительное:проезд{},
существительное:проход{},
существительное:перемещение{},
существительное:перелет{},
существительное:пролет{}
}
fact сущ_предл_сущ
{
if context { Сущ_сквозь_вин предлог:сквозь{} *:*{ падеж:вин } }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_сквозь_вин предлог:сквозь{} @regex("[a-z]+[0-9]*") }
then return true
}
// Подавляем по умолчанию вариант СКВОЗЬ+вин.п.
fact сущ_предл_сущ
{
if context { * предлог:сквозь{} *:*{ падеж:вин } }
then return false,-5
}
#endregion Предлог_СКВОЗЬ
#region Предлог_ДО
// ----------------- ПРЕДЛОГ 'ДО' ----------------------
wordentry_set Сущ_ДО_Род=существительное:{
доведение, // доведение до самоубийства
рейс, // рейс до Сан-Франциско
минута, секунда, год, зима, весна, лето, час, день, ночь, мгновение, // 10 минут до полудня
путь // Тебе предстоит долгий путь до дома
}
fact сущ_предл_сущ
{
if context { Сущ_ДО_Род предлог:до{} *:*{ падеж:род } }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_ДО_Род предлог:до{} @regex("[a-z]+[0-9]*") }
then return true
}
// Она успела сходить в магазин до обеда.
fact сущ_предл_сущ
{
if context { * предлог:до{} * }
then return false,-5
}
#endregion Предлог_ДО
#region Предлог_ИЗ_ЗА
// ----------------- ПРЕДЛОГ 'ИЗ-ЗА' ----------------------
// Он выписал много книг из-за границы.
fact сущ_предл_сущ
{
if context { * предлог:из-за{} * }
then return false,-5
}
#endregion Предлог_ИЗ_ЗА
#region Предлог_ПРИ
// ----------------- ПРЕДЛОГ 'ПРИ' ----------------------
wordentry_set Сущ_ПРИ=существительное:{
изменение, // Изменение свойств при добавлении молока
хозяйство // лесное хозяйство при Правительстве Республики
}
fact сущ_предл_сущ
{
if context { Сущ_ПРИ предлог:при{} * }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_ПРИ предлог:при{} @regex("[a-z]+[0-9]*") }
then return true
}
fact сущ_предл_сущ
{
if context { * предлог:при{} * }
then return false,-5
}
#endregion Предлог_ПРИ
#region Предлог_ПЕРЕД
// ----------------- ПРЕДЛОГ 'ПЕРЕД' ----------------------
wordentry_set Сущ_ПЕРЕД=существительное:{
долг, // это твой долг перед нашим народом!
страх, // можно считать это страхом перед людьми
остановка // существить остановку перед светофором
}
fact сущ_предл_сущ
{
if context { Сущ_ПЕРЕД предлог:перед{} *:*{ падеж:твор } }
then return true
}
fact сущ_предл_сущ
{
if context { Сущ_ПЕРЕД предлог:перед{} @regex("[a-z]+[0-9]*") }
then return true
}
fact сущ_предл_сущ
{
if context { * предлог:перед{} * }
then return false,-5
}
#endregion Предлог_ПЕРЕД
#region С_ПОМОЩЬЮ
// Эта машина приводится в движение с помощью электричества.
fact сущ_предл_сущ
{
if context { * предлог:с помощью{} * }
then return false,-10
}
#endregion С_ПОМОЩЬЮ
#region Предлог_ПОПЕРЕК
// ----------------- ПРЕДЛОГ 'незадолго до' ----------------------
// ножны лежали у Андрея поперек спины.
// ^^^^^^ ^^^^^^^
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:поперек{} * }
then return false
}
#endregion Предлог_ПОПЕРЕК
/*
#region Предлог_ПРЯМО_К
// ----------------- ПРЕДЛОГ 'незадолго до' ----------------------
// он подал лимузин прямо к подъезду
// ^^^^^^^
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:прямо к{} * }
then return false,-10
}
#endregion Предлог_ПРЯМО_К
*/
#region Предлог_ПРИ_ПОМОЩИ
fact сущ_предл_сущ
{
if context { существительное:*{одуш:одуш} предлог:ПРИ ПОМОЩИ{} * }
then return false,-100
}
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:ПРИ ПОМОЩИ{} * }
then return false,-10
}
#endregion Предлог_ПРИ_ПОМОЩИ
#region Предлог_ПУТЕМ
fact сущ_предл_сущ
{
if context { существительное:*{одуш:одуш} предлог:ПУТЕМ{} * }
then return false,-100
}
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:ПУТЕМ{} * }
then return false,-10
}
#endregion Предлог_ПУТЕМ
#region Предлог_В_СООТВЕТСТВИИ_С
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:В СООТВЕТСТВИИ С{} * }
then return false,-100
}
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:В СООТВЕТСТВИИ С{} * }
then return false,-10
}
#endregion Предлог_В_СООТВЕТСТВИИ_С
#region Предлог_В_ТЕЧЕНИЕ
fact сущ_предл_сущ
{
if context { существительное:*{одуш:одуш} предлог:В ТЕЧЕНИЕ{} * }
then return false,-100
}
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:В ТЕЧЕНИЕ{} * }
then return false,-10
}
#endregion Предлог_В_ТЕЧЕНИЕ
#region Предлог_ВО_ВРЕМЯ
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:ВО ВРЕМЯ{} * }
then return false,-100
}
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:ВО ВРЕМЯ{} * }
then return false,-10
}
#endregion Предлог_ВО_ВРЕМЯ
#region Предлог_ВО_ИЗБЕЖАНИЕ
fact сущ_предл_сущ
{
if context { существительное:*{одуш:одуш} предлог:ВО ИЗБЕЖАНИЕ{} * }
then return false,-100
}
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:ВО ИЗБЕЖАНИЕ{} * }
then return false,-10
}
#endregion Предлог_ВО_ИЗБЕЖАНИЕ
#region Предлог_НЕСМОТРЯ_НА
fact сущ_предл_сущ
{
if context { существительное:*{одуш:одуш} предлог:НЕСМОТРЯ НА{} * }
then return false,-100
}
// штрафом наказывается проезд несмотря на запрет
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:НЕСМОТРЯ НА{} * }
then return false,-10
}
#endregion Предлог_НЕСМОТРЯ_НА
#region Предлог_МИМО
// дорога мимо полей вела.
fact сущ_предл_сущ
{
if context { существительное:*{одуш:одуш} предлог:мимо{} * }
then return false,-100
}
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:мимо{} * }
then return false,-5
}
#endregion Предлог_МИМО
#region Послелог_НАВСТРЕЧУ
// тот открыл дверь мне навстречу.
// ^^^^^ ^^^^^^^^^
fact сущ_предл_сущ
{
if context { существительное:*{} послелог:навстречу{} * }
then return false
}
#endregion Послелог_НАВСТРЕЧУ
#region Предлог_НАВСТРЕЧУ
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:навстречу{} * }
then return false,-100
}
// черная машина плыла между деревьями навстречу мне.
// ~~~~~~~~~ ^^^^^^^^^
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:навстречу{} * }
then return false,-5
}
#endregion Предлог_НАВСТРЕЧУ
#region Предлог_ПРОТИВ
// Я настроил твою мать против меня.
// ~~~~ ^^^^^^
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:против{} * }
then return false,-10
}
#endregion Предлог_ПРОТИВ
#region Предлог_ВМЕСТО
// старик вместо ответа махнул рукой.
// ~~~~~~ ^^^^^^
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:вместо{} * }
then return false,-10
}
#endregion Предлог_ВМЕСТО
#region Предлог_РАДИ
// Животные ради удовольствия купаются
// ^^^^ ~~~~~~~~~~~~
fact сущ_предл_сущ
{
if context { существительное:*{ одуш:одуш } предлог:ради{} * }
then return false,-10
}
// делают это ради удовольствия
// ^^^ ~~~~
fact сущ_предл_сущ
{
if context { местоим_сущ:*{} предлог:ради{} * }
then return false,-10
}
#endregion Предлог_ВМЕСТО
#region Предлог_ВПЕРВЫЕ_В
// Биатлонист А.Логинов впервые в жизни завоевал медаль для сборной России
// ^^^^^^^^^
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:впервые в{} * }
then return false,-10
}
#endregion Предлог_ВПЕРВЫЕ_В
/*
#region Предлог_НЕПОДАЛЕКУ_ОТ
// Полиция расследует утечку газа неподалеку от Парижа
// ^^^^^^^^^^^^^
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:неподалеку от{} * }
then return false,-2
}
#endregion Предлог_НЕПОДАЛЕКУ_ОТ
*/
#region Предлог_БЛАГОДАРЯ
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:благодаря{} * }
then return false,-100
}
#endregion Предлог_БЛАГОДАРЯ
#region Предлог_ВПЕРЕД
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:вперед{} * }
then return false,-100
}
#endregion Предлог_ВПЕРЕД
#region Предлог_ВСЛЕД_ЗА
fact сущ_предл_сущ
{
if context { существительное:*{} предлог:вслед за{} * }
then return false,-100
}
#endregion Предлог_ВСЛЕД_ЗА
fact сущ_предл_сущ
{
if context { * * * }
then return true
}
| постепенно его охватило отвращение к себе
| существительное:отвращение{}, | 14,065,272 | [
1,
145,
128,
145,
127,
146,
228,
146,
229,
145,
118,
145,
128,
145,
118,
145,
126,
145,
126,
145,
127,
225,
145,
118,
145,
116,
145,
127,
225,
145,
127,
146,
232,
145,
115,
145,
113,
146,
229,
145,
121,
145,
124,
145,
127,
225,
145,
127,
146,
229,
145,
115,
146,
227,
145,
113,
146,
236,
145,
118,
145,
126,
145,
121,
145,
118,
225,
145,
123,
225,
146,
228,
145,
118,
145,
114,
145,
118,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
146,
228,
146,
230,
146,
236,
145,
118,
146,
228,
146,
229,
145,
115,
145,
121,
146,
229,
145,
118,
145,
124,
146,
239,
145,
126,
145,
127,
145,
118,
30,
145,
127,
146,
229,
145,
115,
146,
227,
145,
113,
146,
236,
145,
118,
145,
126,
145,
121,
145,
118,
2916,
16,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity 0.6.12;
import "../VRFConsumerBase.sol";
contract VRFTestnetD20 is VRFConsumerBase {
using SafeMath_Chainlink for uint;
uint256[] public d20Results;
bytes32 internal keyHash;
uint256 internal fee;
/**
* @notice Constructor inherits VRFConsumerBase
* @dev Ropsten deployment params:
* @dev _vrfCoordinator: 0xf720CF1B963e0e7bE9F58fd471EFa67e7bF00cfb
* @dev _link: 0x20fE562d797A42Dcb3399062AE9546cd06f63280
*/
constructor(address _vrfCoordinator, address _link, bytes32 _keyHash)
VRFConsumerBase(_vrfCoordinator, _link) public
{
keyHash = _keyHash;
fee = 10 ** 18;
}
/**
* @notice Requests randomness from a user-provided seed
* @dev This is only an example implementation and not necessarily suitable for mainnet.
* @dev You must review your implementation details with extreme care.
*/
function rollDice(uint256 userProvidedSeed) public returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) >= fee,
"Not enough LINK - fill contract with faucet");
bytes32 _requestId = requestRandomness(keyHash, fee, userProvidedSeed);
return _requestId;
}
/**
* @notice Callback function used by VRF Coordinator
* @dev Important! Add a modifier to only allow this function to be called by the VRFCoordinator
* @dev This is where you do something with randomness!
* @dev The VRF Coordinator will only send this function verified responses.
*/
function fulfillRandomness(bytes32 /* requestId */, uint256 randomness) internal override {
uint256 d20Result = randomness.mod(20).add(1); // Simplified example
d20Results.push(d20Result);
}
/**
* @notice Convenience function to show the latest roll
*/
function latestRoll() public view returns (uint256 d20result) {
return d20Results[d20Results.length - 1];
}
}
| * @notice Requests randomness from a user-provided seed @dev This is only an example implementation and not necessarily suitable for mainnet. @dev You must review your implementation details with extreme care./ | function rollDice(uint256 userProvidedSeed) public returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) >= fee,
"Not enough LINK - fill contract with faucet");
bytes32 _requestId = requestRandomness(keyHash, fee, userProvidedSeed);
return _requestId;
}
| 13,117,948 | [
1,
6421,
2744,
4496,
628,
279,
729,
17,
29206,
5009,
225,
1220,
353,
1338,
392,
3454,
4471,
471,
486,
23848,
10631,
364,
2774,
2758,
18,
225,
4554,
1297,
10725,
3433,
4471,
3189,
598,
23755,
73,
7671,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
5824,
40,
1812,
12,
11890,
5034,
729,
19254,
12702,
13,
1071,
1135,
261,
3890,
1578,
14459,
13,
288,
203,
3639,
2583,
12,
10554,
18,
12296,
951,
12,
2867,
12,
2211,
3719,
1545,
14036,
16,
203,
1850,
315,
1248,
7304,
22926,
300,
3636,
6835,
598,
11087,
5286,
278,
8863,
203,
3639,
1731,
1578,
389,
2293,
548,
273,
590,
8529,
4496,
12,
856,
2310,
16,
14036,
16,
729,
19254,
12702,
1769,
203,
3639,
327,
389,
2293,
548,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
//Address: 0x261ace754fba8af93e1fecdff13640540402940f
//Contract name: Phila_Token
//Balance: 0 Ether
//Verification Date: 5/23/2018
//Transacion Count: 6
// CODE STARTS HERE
pragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract Phila_Token is ERC20Interface, Owned {
string public constant symbol = "φιλα";
string public constant name = "φιλανθρωπία";
uint8 public constant decimals = 0;
uint private constant _totalSupply = 10000000;
address public vaultAddress;
bool public fundingEnabled;
uint public totalCollected; // In wei
uint public tokenPrice; // In wei
mapping(address => uint) balances;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
balances[this] = _totalSupply;
emit Transfer(address(0), this, _totalSupply);
}
function setVaultAddress(address _vaultAddress) public onlyOwner {
vaultAddress = _vaultAddress;
return;
}
function setFundingEnabled(bool _fundingEnabled) public onlyOwner {
fundingEnabled = _fundingEnabled;
return;
}
function updateTokenPrice(uint _newTokenPrice) public onlyOwner {
require(_newTokenPrice > 0);
tokenPrice = _newTokenPrice;
return;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
//
// THIS TOKENS ARE NOT TRANSFERRABLE.
//
// ------------------------------------------------------------------------
function approve(address, uint) public returns (bool) {
revert();
return false;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
//
// THIS TOKENS ARE NOT TRANSFERRABLE.
//
// ------------------------------------------------------------------------
function allowance(address, address) public constant returns (uint) {
return 0;
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
//
// THIS TOKENS ARE NOT TRANSFERRABLE.
//
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address _to, uint _amount) public returns (bool) {
if (_amount == 0) {
emit Transfer(msg.sender, _to, _amount); // Follow the spec to louch the event when transfer 0
return true;
}
revert();
return false;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// THIS TOKENS ARE NOT TRANSFERRABLE.
//
// ------------------------------------------------------------------------
function transferFrom(address, address, uint) public returns (bool) {
revert();
return false;
}
function () public payable {
require (fundingEnabled && (tokenPrice > 0) && (msg.value >= tokenPrice));
totalCollected += msg.value;
//Send the ether to the vault
vaultAddress.transfer(msg.value);
uint tokens = msg.value / tokenPrice;
// Do not allow transfer to 0x0 or the token contract itself
require((msg.sender != 0) && (msg.sender != address(this)));
// If the amount being transfered is more than the balance of the
// account the transfer throws
uint previousBalanceFrom = balances[this];
require(previousBalanceFrom >= tokens);
// First update the balance array with the new value for the address
// sending the tokens
balances[this] = previousBalanceFrom - tokens;
// Then update the balance array with the new value for the address
// receiving the tokens
uint previousBalanceTo = balances[msg.sender];
require(previousBalanceTo + tokens >= previousBalanceTo); // Check for overflow
balances[msg.sender] = previousBalanceTo + tokens;
// An event to make the transfer easy to find on the blockchain
emit Transfer(this, msg.sender, tokens);
return;
}
/// @notice This method can be used by the owner to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
//
// THIS TOKENS ARE NOT TRANSFERRABLE.
//
function claimTokens(address _token) public onlyOwner {
require(_token != address(this));
if (_token == 0x0) {
owner.transfer(address(this).balance);
return;
}
ERC20Interface token = ERC20Interface(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
emit ClaimedTokens(_token, owner, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
| Send the ether to the vault Do not allow transfer to 0x0 or the token contract itself If the amount being transfered is more than the balance of the account the transfer throws First update the balance array with the new value for the address sending the tokens Then update the balance array with the new value for the address receiving the tokens An event to make the transfer easy to find on the blockchain | function () public payable {
require (fundingEnabled && (tokenPrice > 0) && (msg.value >= tokenPrice));
totalCollected += msg.value;
vaultAddress.transfer(msg.value);
uint tokens = msg.value / tokenPrice;
require((msg.sender != 0) && (msg.sender != address(this)));
uint previousBalanceFrom = balances[this];
require(previousBalanceFrom >= tokens);
balances[this] = previousBalanceFrom - tokens;
uint previousBalanceTo = balances[msg.sender];
balances[msg.sender] = previousBalanceTo + tokens;
emit Transfer(this, msg.sender, tokens);
return;
}
| 945,778 | [
1,
3826,
326,
225,
2437,
358,
326,
9229,
2256,
486,
1699,
7412,
358,
374,
92,
20,
578,
326,
1147,
6835,
6174,
971,
326,
3844,
3832,
7412,
329,
353,
1898,
2353,
326,
11013,
434,
326,
225,
2236,
326,
7412,
1216,
5783,
1089,
326,
11013,
526,
598,
326,
394,
460,
364,
326,
1758,
225,
5431,
326,
2430,
9697,
1089,
326,
11013,
526,
598,
326,
394,
460,
364,
326,
1758,
225,
15847,
326,
2430,
1922,
871,
358,
1221,
326,
7412,
12779,
358,
1104,
603,
326,
16766,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
1832,
1071,
8843,
429,
288,
203,
3639,
2583,
261,
74,
14351,
1526,
597,
261,
2316,
5147,
405,
374,
13,
597,
261,
3576,
18,
1132,
1545,
1147,
5147,
10019,
203,
540,
203,
3639,
2078,
10808,
329,
1011,
1234,
18,
1132,
31,
203,
203,
3639,
9229,
1887,
18,
13866,
12,
3576,
18,
1132,
1769,
203,
203,
3639,
2254,
2430,
273,
1234,
18,
1132,
342,
1147,
5147,
31,
203,
203,
6647,
2583,
12443,
3576,
18,
15330,
480,
374,
13,
597,
261,
3576,
18,
15330,
480,
1758,
12,
2211,
3719,
1769,
203,
203,
6647,
2254,
2416,
13937,
1265,
273,
324,
26488,
63,
2211,
15533,
203,
203,
6647,
2583,
12,
11515,
13937,
1265,
1545,
2430,
1769,
203,
203,
6647,
324,
26488,
63,
2211,
65,
273,
2416,
13937,
1265,
300,
2430,
31,
203,
203,
6647,
2254,
2416,
13937,
774,
273,
324,
26488,
63,
3576,
18,
15330,
15533,
203,
6647,
324,
26488,
63,
3576,
18,
15330,
65,
273,
2416,
13937,
774,
397,
2430,
31,
203,
203,
6647,
3626,
12279,
12,
2211,
16,
1234,
18,
15330,
16,
2430,
1769,
203,
203,
3639,
327,
31,
203,
565,
289,
203,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
/**
*Submitted for verification at Etherscan.io on 2021-11-30
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-29
*/
/**
Multi-Chain Capital: $MCC
You buy on Ethereum. Farmers gain incentives to farm on multiple chains and return the profits to $MCC holders through buybacks.
Tokenomics:
10% of each buy is proportionally distributed to existing holders via "reflections".
10% of each sell goes into multi-chain farming to add to the treasury and buy back MCC tokens.
Website (Web 3.0):
ipfs://multichaincapital.eth
Website (Web 2.5):
https://multichaincapital.eth.limo
Website (Web 2.0):
https://mcc.holdings
Telegram:
https://t.me/MultiChainCapital
Twitter:
https://twitter.com/MulChainCapital
Medium:
https://multichaincapital.medium.com
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract MultiChainCapitalV2 is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
/**
* [ADDRESS MAPPINGS]
*
*/
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isMultisig;
address[] private multisigParties;
bool public multisigDestroyed = false;
struct TreasuryNomination {
address nominee;
bool valid;
}
struct WhitelistNomination {
address nominee;
bool valid;
}
struct DestructionNomination {
bool valid;
}
mapping (address => TreasuryNomination) private _treasuryNominations;
mapping (address => WhitelistNomination) private _whitelistNominations;
mapping (address => DestructionNomination) private _destructionNominations;
/**
* [MISC. VARIABLES]
*
*/
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'MultiChainCapital';
string private _symbol = 'MCC';
uint8 private _decimals = 9;
uint256 private _taxFee = 10;
uint256 private _teamFee = 10;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousTeamFee = _teamFee;
address payable public MCCTreasury;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwap = false;
bool public swapEnabled = true;
// Has the treasury been linked yet:
bool treasuryLinked = false;
uint256 private _maxTxAmount = 100000000000000e9;
// We will set a minimum amount of tokens to be swaped => 5M
uint256 private _numOfTokensToExchangeForTeam = 5 * 10**3 * 10**9;
/**
* [EVENTS]
*
*/
event MinTokensBeforeSwapUpdated(
uint256 minTokensBeforeSwap
);
event SwapEnabledUpdated(
bool enabled
);
/**
* [MODIFIERS]
*
*/
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
modifier onlyMultisig {
require(_isMultisig[msg.sender], "You are not a multisig party.");
_;
}
/**
* [CONSTRUCTOR]
*
*/
constructor (
address payable _MCCTreasury,
address[] memory _multisigParties
//IUniswapV2Router02 _uniswapV2Router
) public {
require(_multisigParties.length == 7, "There must be 7 multisig parties.");
MCCTreasury = _MCCTreasury;
_rOwned[_msgSender()] = _rTotal;
multisigParties = _multisigParties;
for (uint8 i = 0; i < multisigParties.length; i++) {
_isMultisig[multisigParties[i]] = true;
}
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); // UniswapV2 for Ethereum network
// Create a uniswap pair for this new token
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
// set the rest of the contract variables
uniswapV2Router = _uniswapV2Router;
// Exclude contract from fee
_isExcludedFromFee[address(this)] = true;
emit Transfer(
address(0),
_msgSender(),
_tTotal
);
}
/**
* [STANDARD ERC20 FUNCTIONS]
*
*/
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(
address account
) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(
address owner,
address spender
) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* [ALLOWANCE FUNCTIONS]
*
*/
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* [TAX WHITELIST FUNCTIONS]
*
*/
function isExcludedFromFee(
address account
) public view returns (bool) {
return _isExcludedFromFee[account];
}
/**
* [BUY TAX (REFLECTION) FUNCTIONS]
*
*/
function reflectionFromToken(
uint256 tAmount,
bool deductTransferFee
) public view returns (uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(
uint256 rAmount
) public view returns (uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function deliver(
uint256 tAmount
) public {
address sender = _msgSender();
(uint256 rAmount,,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
/**
* [SELL TAX FUNCTIONS]
*
*/
function sendETHToTeam(
uint256 amount
) private {
MCCTreasury.transfer(amount);
}
/**
* [UTILITY FUNCTIONS]
*
*/
function removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousTeamFee = _teamFee;
_taxFee = 0;
_teamFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousTeamFee;
}
/**
* [CUSTOM STANDARD FUNCTION EXTENSIONS]
*
*/
function _approve(
address owner,
address spender,
uint256 amount
) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(
address sender,
address recipient,
uint256 amount
) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (sender != owner() && recipient != owner()) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
// is the token balance of this contract address over the min number of
// tokens that we need to initiate a swap?
// also, don't get caught in a circular team event.
// also, don't swap if sender is uniswap pair.
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= _maxTxAmount) {
contractTokenBalance = _maxTxAmount;
}
bool overMinTokenBalance = contractTokenBalance >= _numOfTokensToExchangeForTeam;
if (!inSwap && swapEnabled && overMinTokenBalance && sender != uniswapV2Pair) {
// We need to swap the current tokens to ETH and send to the team wallet
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToTeam(address(this).balance);
}
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]){
takeFee = false;
}
//transfer amount, it will take tax and team fee
_tokenTransfer(sender,recipient,amount,takeFee);
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
if(!takeFee) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(!takeFee) {
restoreAllFee();
}
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rTeam, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(rTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
/**
* [UNISWAP V2 FUNCTIONS]
*
*/
function swapTokensForEth(
uint256 tokenAmount
) private lockTheSwap{
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
/**
* [MISC. PRIVATE FEE FUNCTIONS]
*
*/
function _takeTeam(
uint256 rTeam
) private {
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(
uint256 rFee,
uint256 tFee
) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
/**
* [PRIVATE PURE FUNCTIONS]
*
*/
function _getTValues(
uint256 tAmount,
uint256 taxFee,
uint256 teamFee
) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(teamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
) private pure returns (uint256, uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee, rTeam);
}
/**
* [PRIVATE VIEW FUNCTIONS]
*
*/
function _getValues(
uint256 tAmount
) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rTeam) = _getRValues(tAmount, tFee, tTeam, _getRate());
return (rAmount, rTransferAmount, rFee, rTeam, tTransferAmount, tFee, tTeam);
}
function _getRate() private view returns (uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns (uint256) {
return _taxFee;
}
function _getMaxTxAmount() private view returns (uint256) {
return _maxTxAmount;
}
/**
* [PUBLIC VIEW FUNCTIONS]
*
*/
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function _getETHBalance() public view returns (uint256 balance) {
return address(this).balance;
}
function isMultisigDestroyed() public view returns (bool) {
return multisigDestroyed;
}
function isMultisigParty(
address _party
) public view returns (bool) {
return _isMultisig[_party];
}
function getTreasury() public view returns (address payable) {
return MCCTreasury;
}
/**
* [MULTISIG]
*
*/
function _nominateTreasury(
address _nominee,
bool _valid
) external onlyMultisig() {
require(multisigDestroyed == false, "The multisig has been destroyed.");
require(treasuryLinked == false, "The treasury contract has already been linked.");
_treasuryNominations[msg.sender].nominee = _nominee;
_treasuryNominations[msg.sender].valid = _valid;
}
function _linkTreasury(
address _MCCTreasury
) external onlyMultisig() {
require(multisigDestroyed == false, "The multisig has been destroyed.");
require(treasuryLinked == false, "The treasury contract has already been linked.");
uint8 agreements = 0;
for (uint8 i = 0; i < multisigParties.length; i++) {
if (_treasuryNominations[multisigParties[i]].nominee == _MCCTreasury && _treasuryNominations[multisigParties[i]].valid == true) {
agreements++;
}
}
require(agreements >= 5, "Multisig requires 5/7 approval.");
_isExcludedFromFee[_MCCTreasury] = true;
MCCTreasury = payable(_MCCTreasury);
treasuryLinked = true;
}
function _nominateFeeExclusion(
address _nominee,
bool _valid
) external onlyMultisig() {
require(multisigDestroyed == false, "The multisig has been destroyed.");
_whitelistNominations[msg.sender].nominee = _nominee;
_whitelistNominations[msg.sender].valid = _valid;
}
function setExcludeFromFee(
address _nominee,
bool _excluded
) external onlyMultisig() {
require(multisigDestroyed == false, "The multisig has been destroyed.");
uint8 agreements = 0;
for (uint8 i = 0; i < multisigParties.length; i++) {
if (_treasuryNominations[multisigParties[i]].nominee == _nominee && _treasuryNominations[multisigParties[i]].valid == _excluded) {
agreements++;
}
}
require(agreements >= 5, "Multisig requires 5/7 approval.");
_isExcludedFromFee[_nominee] = _excluded;
}
function _nominateDestruction(
bool _valid
) external onlyMultisig() {
require(multisigDestroyed == false, "The multisig has been destroyed.");
_destructionNominations[msg.sender].valid = _valid;
}
function _destroyMultisig() external onlyMultisig() {
require(multisigDestroyed == false, "The multisig has been destroyed.");
uint8 agreements = 0;
for (uint8 i = 0; i < multisigParties.length; i++) {
if (_destructionNominations[multisigParties[i]].valid == true) {
agreements++;
}
}
require(agreements >= 5, "Multisig requires 5/7 approval.");
multisigDestroyed = true;
}
} | IUniswapV2Router02 _uniswapV2Router | ) public {
require(_multisigParties.length == 7, "There must be 7 multisig parties.");
MCCTreasury = _MCCTreasury;
_rOwned[_msgSender()] = _rTotal;
multisigParties = _multisigParties;
for (uint8 i = 0; i < multisigParties.length; i++) {
_isMultisig[multisigParties[i]] = true;
}
emit Transfer(
address(0),
_msgSender(),
_tTotal
);
}
| 7,978,659 | [
1,
45,
984,
291,
91,
438,
58,
22,
8259,
3103,
389,
318,
291,
91,
438,
58,
22,
8259,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
262,
1071,
288,
203,
3639,
2583,
24899,
23978,
360,
1988,
606,
18,
2469,
422,
2371,
16,
315,
9828,
1297,
506,
2371,
22945,
360,
1087,
606,
1199,
1769,
203,
203,
3639,
24105,
1268,
266,
345,
22498,
273,
389,
20022,
1268,
266,
345,
22498,
31,
203,
3639,
389,
86,
5460,
329,
63,
67,
3576,
12021,
1435,
65,
273,
389,
86,
5269,
31,
203,
203,
3639,
22945,
360,
1988,
606,
273,
389,
23978,
360,
1988,
606,
31,
203,
3639,
364,
261,
11890,
28,
277,
273,
374,
31,
277,
411,
22945,
360,
1988,
606,
18,
2469,
31,
277,
27245,
288,
203,
5411,
389,
291,
5049,
291,
360,
63,
23978,
360,
1988,
606,
63,
77,
13563,
273,
638,
31,
203,
3639,
289,
203,
203,
203,
203,
203,
3639,
3626,
12279,
12,
203,
5411,
1758,
12,
20,
3631,
203,
5411,
389,
3576,
12021,
9334,
203,
5411,
389,
88,
5269,
203,
3639,
11272,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/80001/0xFe244Bbd340cbA81F4106F2B0B936453D1B1E2B6/sources/project_/contracts/superfluid/SuperfluidPool.sol | update pool's disconnected units trigger the side effect of claiming all if not connected update pool's disconnected units update pool member's units | function _updateMember(address memberAddr, uint128 newUnits) internal returns (bool) {
if (GDA.isPool(superToken, memberAddr)) revert SUPERFLUID_POOL_NO_POOL_MEMBERS();
if (memberAddr == address(0)) revert SUPERFLUID_POOL_NO_ZERO_ADDRESS();
uint32 time = uint32(ISuperfluid(superToken.getHost()).getNow());
Time t = Time.wrap(time);
Unit wrappedUnits = Unit.wrap(uint256(newUnits).toInt256().toInt128());
PDPoolIndex memory pdPoolIndex = poolIndexDataToPDPoolIndex(_index);
PDPoolMember memory pdPoolMember = _memberDataToPDPoolMember(_membersData[memberAddr]);
PDPoolMemberMU memory mu = PDPoolMemberMU(pdPoolIndex, pdPoolMember);
if (!GDA.isMemberConnected(superToken, address(this), memberAddr)) {
int256 claimedAmount = _claimAll(memberAddr, time);
_shiftDisconnectedUnits(wrappedUnits - mu.m.owned_units, Value.wrap(claimedAmount), t);
}
{
BasicParticle memory p;
(pdPoolIndex, pdPoolMember, p) = mu.pool_member_update(p, wrappedUnits, t);
_index = _pdPoolIndexToPoolIndexData(pdPoolIndex);
int256 claimedValue = _membersData[memberAddr].claimedValue;
_membersData[memberAddr] = _pdPoolMemberToMemberData(pdPoolMember, claimedValue);
assert(GDA.appendIndexUpdateByPool(superToken, p, t));
}
emit MemberUpdated(memberAddr, newUnits);
uint256 tokenId = poolMemberNFT.getTokenId(address(this), memberAddr);
if (newUnits == 0) {
if (poolMemberNFT.getPoolMemberData(tokenId).member != address(0)) {
poolMemberNFT.burn(tokenId);
}
if (poolMemberNFT.getPoolMemberData(tokenId).member == address(0)) {
poolMemberNFT.mint(address(this), memberAddr);
}
}
return true;
}
| 841,427 | [
1,
2725,
2845,
1807,
17853,
4971,
3080,
326,
4889,
5426,
434,
7516,
310,
777,
309,
486,
5840,
1089,
2845,
1807,
17853,
4971,
1089,
2845,
3140,
1807,
4971,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
389,
2725,
4419,
12,
2867,
3140,
3178,
16,
2254,
10392,
394,
7537,
13,
2713,
1135,
261,
6430,
13,
288,
203,
3639,
309,
261,
43,
9793,
18,
291,
2864,
12,
9565,
1345,
16,
3140,
3178,
3719,
15226,
16459,
654,
19054,
3060,
67,
20339,
67,
3417,
67,
20339,
67,
19630,
55,
5621,
203,
3639,
309,
261,
5990,
3178,
422,
1758,
12,
20,
3719,
15226,
16459,
654,
19054,
3060,
67,
20339,
67,
3417,
67,
24968,
67,
15140,
5621,
203,
203,
3639,
2254,
1578,
813,
273,
2254,
1578,
12,
45,
8051,
2242,
1911,
12,
9565,
1345,
18,
588,
2594,
1435,
2934,
588,
8674,
10663,
203,
3639,
2647,
268,
273,
2647,
18,
4113,
12,
957,
1769,
203,
3639,
8380,
5805,
7537,
273,
8380,
18,
4113,
12,
11890,
5034,
12,
2704,
7537,
2934,
869,
1702,
5034,
7675,
869,
1702,
10392,
10663,
203,
203,
3639,
28704,
2864,
1016,
3778,
4863,
2864,
1016,
273,
2845,
1016,
751,
774,
21527,
2864,
1016,
24899,
1615,
1769,
203,
3639,
28704,
2864,
4419,
3778,
4863,
2864,
4419,
273,
389,
5990,
751,
774,
21527,
2864,
4419,
24899,
7640,
751,
63,
5990,
3178,
19226,
203,
3639,
28704,
2864,
4419,
49,
57,
3778,
4129,
273,
28704,
2864,
4419,
49,
57,
12,
22353,
2864,
1016,
16,
4863,
2864,
4419,
1769,
203,
203,
3639,
309,
16051,
43,
9793,
18,
291,
4419,
8932,
12,
9565,
1345,
16,
1758,
12,
2211,
3631,
3140,
3178,
3719,
288,
203,
5411,
509,
5034,
7516,
329,
6275,
273,
389,
14784,
1595,
12,
5990,
3178,
16,
813,
1769,
203,
203,
5411,
389,
4012,
26303,
7537,
12,
2
]
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
interface IPremiaMining {
function deposit(uint256 _pid, uint256 _amount) external;
}
/// @author Premia
/// @title Token to drain reward from the deprecated interaction mining contract towards the mining fund
contract PremiaMiningDrain is ERC20("MiningDrainToken", "MiningDrain") {
IERC20 public premia = IERC20(0x6399C842dD2bE3dE30BF99Bc7D1bBF6Fa3650E70);
IPremiaMining public premiaMining = IPremiaMining(0xf0f16B3460512554d4D821DD482dbfb78817EC43);
address public miningFund = 0x81d6F46981B4fE4A6FafADDa716eE561A17761aE;
uint256 public pid = 1;
constructor() public {
_mint(address(this), 1);
}
function transferReward() public {
// Harvest pending reward
premiaMining.deposit(pid, 0);
premia.transfer(miningFund, premia.balanceOf(address(this)));
}
function deposit() public {
_approve(address(this), address(premiaMining), 1);
premiaMining.deposit(pid, 1);
}
} | @author Premia @title Token to drain reward from the deprecated interaction mining contract towards the mining fund | contract PremiaMiningDrain is ERC20("MiningDrainToken", "MiningDrain") {
IERC20 public premia = IERC20(0x6399C842dD2bE3dE30BF99Bc7D1bBF6Fa3650E70);
IPremiaMining public premiaMining = IPremiaMining(0xf0f16B3460512554d4D821DD482dbfb78817EC43);
address public miningFund = 0x81d6F46981B4fE4A6FafADDa716eE561A17761aE;
uint256 public pid = 1;
constructor() public {
_mint(address(this), 1);
}
function transferReward() public {
premiaMining.deposit(pid, 0);
premia.transfer(miningFund, premia.balanceOf(address(this)));
}
function deposit() public {
_approve(address(this), address(premiaMining), 1);
premiaMining.deposit(pid, 1);
}
} | 1,797,802 | [
1,
23890,
1155,
225,
3155,
358,
15427,
19890,
628,
326,
6849,
13581,
1131,
310,
6835,
23248,
326,
1131,
310,
284,
1074,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
453,
2764,
1155,
2930,
310,
26896,
353,
4232,
39,
3462,
2932,
2930,
310,
26896,
1345,
3113,
315,
2930,
310,
26896,
7923,
288,
203,
565,
467,
654,
39,
3462,
1071,
23020,
1155,
273,
467,
654,
39,
3462,
12,
20,
92,
4449,
2733,
39,
5193,
22,
72,
40,
22,
70,
41,
23,
72,
41,
5082,
15259,
2733,
38,
71,
27,
40,
21,
70,
15259,
26,
29634,
5718,
3361,
41,
7301,
1769,
203,
565,
467,
23890,
1155,
2930,
310,
1071,
23020,
1155,
2930,
310,
273,
467,
23890,
1155,
2930,
310,
12,
20,
5841,
20,
74,
2313,
38,
5026,
4848,
13757,
2539,
24,
72,
24,
40,
28,
5340,
5698,
8875,
22,
1966,
19192,
27,
5482,
4033,
7228,
8942,
1769,
203,
565,
1758,
1071,
1131,
310,
42,
1074,
273,
374,
92,
11861,
72,
26,
42,
24,
8148,
11861,
38,
24,
74,
41,
24,
37,
26,
42,
1727,
8355,
69,
27,
2313,
73,
41,
4313,
21,
37,
4033,
6669,
21,
69,
41,
31,
203,
565,
2254,
5034,
1071,
4231,
273,
404,
31,
203,
203,
565,
3885,
1435,
1071,
288,
203,
3639,
389,
81,
474,
12,
2867,
12,
2211,
3631,
404,
1769,
203,
565,
289,
203,
203,
565,
445,
7412,
17631,
1060,
1435,
1071,
288,
203,
3639,
23020,
1155,
2930,
310,
18,
323,
1724,
12,
6610,
16,
374,
1769,
203,
3639,
23020,
1155,
18,
13866,
12,
1154,
310,
42,
1074,
16,
23020,
1155,
18,
12296,
951,
12,
2867,
12,
2211,
3719,
1769,
203,
565,
289,
203,
203,
565,
445,
443,
1724,
1435,
1071,
288,
203,
3639,
389,
12908,
537,
12,
2
]
|
// SPDX-License-Identifier: MIT
// USAGE
// IF YOU ARE NOT THE OWNER OF THIS CONTRACT INSTANCE, DO NOT SEND TOKENS DIRECTLY TO THIS CONTRACT.
// IF YOU ARE AN END USER, ONLY USE THIS CONTRACT THROUGH THE INTERFACE (available at https://github.com/second-state/interest-earner-user-interface).
// DO NOT SEND ETH TO THIS CONTRACT.
// WARNING
// This contract has NOT been independently tested or audited.
// DO NOT use this contract with funds of real value until officially tested and audited by an independent expert or group.
pragma solidity 0.8.11;
// SafeERC20
// The following version of SafeERC20 is used.
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
// SafeMath
// The following version of SafeMath is used because this contract uses Solidity 0.8 or later (i.e. the compiler has built in overflow checks).
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol
import "openzeppelin-solidity/contracts/utils/math/SafeMath.sol";
contract InterestEarner {
// boolean to prevent reentrancy
bool internal locked;
// Library usage
using SafeERC20 for IERC20;
using SafeMath for uint256;
// Input validation
uint256 internal MAX_INT = 2**256 - 1;
// Contract owner
address public owner;
// Timestamp related variables
// The timestamp at the time the user initially staked their tokens
mapping(address => uint256) public initialStakingTimestamp;
bool public timePeriodSet;
uint256 public timePeriod;
// Yield related variables
bool public percentageSet;
uint256 public percentageBasisPoints;
mapping(address => uint256) public expectedInterest;
uint256 public totalExpectedInterest;
// Token amount variables
mapping(address => uint256) public balances;
uint256 public totalStateStaked;
// ERC20 contract address
IERC20 public erc20Contract;
// Events
event TokensStaked(address from, uint256 amount);
event TokensUnstaked(address to, uint256 amount);
event InterestEarned(address to, uint256 amount);
event InterestWithdrawn(address to, uint256 amount);
/// @dev Deploys contract and links the ERC20 token which we are staking, also sets owner as msg.sender and sets timePeriodIsSet & percentageSet & locked bools to false.
/// @param _erc20_contract_address.
constructor(IERC20 _erc20_contract_address) {
// Set contract owner
owner = msg.sender;
// Time period value not set yet
timePeriodSet = false;
// Perdentage value not set yet
percentageSet = false;
// Set the erc20 contract address which this timelock is deliberately paired to
require(address(_erc20_contract_address) != address(0), "_erc20_contract_address address can not be zero");
require(address(msg.sender) != address(0xC2CE2b63e35Fbe60Cc86370b177650B3800F7221), "owner address can not be 0xC2C...F7221");
erc20Contract = _erc20_contract_address;
// Initialize the reentrancy variable to not locked
locked = false;
// Initialize the total amount of STATE staked
totalStateStaked = 0;
// Initialize the time period
timePeriod = 0;
// Initialize the base points (bps)
percentageBasisPoints = 0;
// Initialize total expectedinterest
totalExpectedInterest = 0;
}
// Modifier
/**
* @dev Prevents reentrancy
*/
modifier noReentrant() {
require(!locked, "No re-entrancy");
locked = true;
_;
locked = false;
}
// Modifier
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner, "Message sender must be the contract's owner.");
_;
}
// Modifier
/**
* @dev Throws if time period already set.
*/
modifier timePeriodNotSet() {
require(timePeriodSet == false, "The time stamp has already been set.");
_;
}
// Modifier
/**
* @dev Throws if time period is not set.
*/
modifier timePeriodIsSet() {
require(timePeriodSet == true, "Please set the time stamp first, then try again.");
_;
}
// Modifier
/**
* @dev Throws if time percentageBasisPoints already set.
*/
modifier percentageNotSet() {
require(percentageSet == false, "The percentageBasisPoints has already been set.");
_;
}
// Modifier
/**
* @dev Throws if percentageBasisPoints is not set.
*/
modifier percentageIsSet() {
require(percentageSet == true, "Please set the percentageBasisPoints variable first, then try again.");
_;
}
/// @dev Sets the staking period for this specific contract instance (in seconds) i.e. 3600 = 1 hour
/// @param _timePeriodInSeconds is the amount of seconds which the contract will add to the a user's initialStakingTimestamp mapping, each time a user initiates a staking action
function setTimePeriod(uint256 _timePeriodInSeconds) public onlyOwner timePeriodNotSet {
timePeriodSet = true;
timePeriod = _timePeriodInSeconds;
}
/// @dev Sets the percentageBasisPoints rate (in Wei) for this specific contract instance
/// 10000 wei is equivalent to 100%
/// 1000 wei is equivalent to 10%
/// 100 wei is equivalent to 1%
/// 10 wei is equivalent to 0.1%
/// 1 wei is equivalent to 0.01%
/// Whereby a traditional floating point percentage like 8.54% would simply be 854 percentage basis points (or in terms of the ethereum uint256 variable, 854 wei)
/// @param _percentageBasisPoints is the annual percentage yield as per the above instructions
function setPercentage(uint256 _percentageBasisPoints) public onlyOwner percentageNotSet {
require(_percentageBasisPoints >= 1 && _percentageBasisPoints <= 10000, "Percentage must be a value >=1 and <= 10000");
percentageSet = true;
percentageBasisPoints = _percentageBasisPoints;
}
/// @dev Allows the contract to share the amount of ERC20 tokens which are staked by its users
/// @return amount of tokens currently staked
function getTotalStakedStake() public view returns (uint256) {
return totalStateStaked;
}
/// @dev Allows the contract to share the current total expected interest which will be paid to all users
/// @return amount of tokens currently owned to users
function getTotalExpectedInterest() public view returns (uint256) {
return totalExpectedInterest;
}
/// @dev Allows the contract to share its amount of ERC20 tokens i.e. the reserve pool which pays out each of the user's interest
/// @param token, the official ERC20 token which this contract exclusively accepts.
/// @return amount of tokens in reserve pool
function getReservePoolAmount(IERC20 token) public view returns (uint256) {
return token.balanceOf(address(this));
}
/// @dev Allows the contract owner to allocate official ERC20 tokens to each future recipient (only one at a time).
/// @param token, the official ERC20 token which this contract exclusively accepts.
/// @param amount to allocate to recipient.
function stakeTokens(IERC20 token, uint256 amount) public timePeriodIsSet percentageIsSet noReentrant{
// Ensure that we are communicating with official ERC20 and not some other random ERC20 contract
require(token == erc20Contract, "You are only allowed to stake the official erc20 token address which was passed into this contract's constructor");
// Ensure that the message sender actually has enough tokens in their wallet to proceed
require(amount <= token.balanceOf(msg.sender), "Not enough ERC20 tokens in your wallet, please try lesser amount");
// Ensure minimum "amount" requirements
// Details:
// There are 31536000 seconds in a year
// We use percentage basis points which have a max value of 10, 000 (i.e. a range from 1 to 10, 000 which is equivalent to 0.01% to 100% interest)
// Therefore, in terms of minimum allowable value, we need the staked amount to always be greater than 0.00000031536 ETH
// Having this minimum amount will avoid us having any zero values in our calculations (anything multiplied by zero is zero; must avoid this at all costs)
// This is fair enough given that this approach allows us to calculate interest down to 0.01% increments with minimal rounding adjustments
require(amount > 315360000000, "Amount to stake must be greater than 0.00000031536 ETH");
// Similarly, in terms of maximum allowable value, we need the staked amount to be less than 2**256 - 1 / 10, 000 (to avoid overflow)
require(amount < MAX_INT.div(10000) , "Maximum amount must be smaller, please try again");
// If this is the first time an external account address is staking, then we need to set the initial staking timestamp to the currently block's timestamp
if (initialStakingTimestamp[msg.sender] == 0){
initialStakingTimestamp[msg.sender] = block.timestamp;
}
// Let's calculate the maximum amount which can be earned per annum (start with mul calculation first so we avoid values lower than one)
uint256 interestEarnedPerAnnum_pre = amount.mul(percentageBasisPoints);
// We use basis points so that Ethereum's uint256 (which does not have decimals) can have percentages of 0.01% increments. The following line caters for the basis points offset
uint256 interestEarnedPerAnnum_post = interestEarnedPerAnnum_pre.div(10000);
// Let's calculate how many wei are earned per second
uint256 weiPerSecond = interestEarnedPerAnnum_post.div(31536000);
require(weiPerSecond > 0, "Interest on this amount is too low to calculate, please try a greater amount");
// Let's calculate the release date
uint256 releaseEpoch = initialStakingTimestamp[msg.sender].add(timePeriod);
// Test to see if the term has already ended
require(block.timestamp < releaseEpoch, "Term has already ended");
// Let's fragment the interest earned per annum down to the remaining time left on this staking round
require(releaseEpoch.sub(block.timestamp) > 0, "There is not enough time left to stake for this current round, please un-stake first");
uint256 secondsRemaining = releaseEpoch.sub(block.timestamp);
// There are 31536000 seconds per annum, so let's calculate the interest for this remaining time period
uint256 interestEarnedForThisStake = weiPerSecond.mul(secondsRemaining);
// Make sure that contract's reserve pool has enough to service this transaction. I.e. there is enough STATE in this contract to pay this user's interest (not including/counting any previous end user's staked STATE or interest which they will eventually take as a pay out)
require(token.balanceOf(address(this)) >= totalStateStaked.add(totalExpectedInterest).add(interestEarnedForThisStake), "Not enough STATE tokens in the reserve pool, please contact owner of this contract");
// Adding this user's expected interest to the expected interest variable
totalExpectedInterest = totalExpectedInterest.add(interestEarnedForThisStake);
// Increment the total State staked
totalStateStaked = totalStateStaked.add(amount);
// Transfer the tokens into the contract (stake/lock)
token.safeTransferFrom(msg.sender, address(this), amount);
// Update this user's locked amount (the amount the user is entitled to unstake/unlock)
balances[msg.sender] = balances[msg.sender].add(amount);
// Update this user's interest component i.e. the amount of interest which will be paid from the reserve pool during unstaking
expectedInterest[msg.sender] = expectedInterest[msg.sender].add(interestEarnedForThisStake);
// Emit the log for this transaction
emit TokensStaked(msg.sender, amount);
emit InterestEarned(msg.sender, interestEarnedForThisStake);
}
/// @dev Allows user to unstake tokens and withdraw their interest after the correct time period has elapsed. All funds are released and the user's initial staking timestamp is reset to allow for the user to start another round of interest earning. A single user can not have overlapping rounds of staking.
// All tokens are unstaked and all interest earned during the elapsed time period is paid out
/// @param token - address of the official ERC20 token which is being unlocked here.
function unstakeAllTokensAndWithdrawInterestEarned(IERC20 token) public timePeriodIsSet percentageIsSet noReentrant {
// Ensure that there is a current round of interest at play
require(initialStakingTimestamp[msg.sender] != 0, "No tokens staked at present");
// Ensure that the current time period has elapsed and that funds are ready to be unstaked
require(block.timestamp > (initialStakingTimestamp[msg.sender].add(timePeriod)), "Locking time period is still active, please try again later");
// Ensure the official ERC20 contract is being referenced
require(token == erc20Contract, "Token parameter must be the same as the erc20 contract address which was passed into the constructor");
// Both expectedInterest and balances must be sent back to the user's wallet as part of this function
// Create a value which represents the amount of tokens about to be unstaked
uint256 amountToUnstake = balances[msg.sender];
// Decrease the total STATE staked
totalStateStaked = totalStateStaked.sub(amountToUnstake);
// Create a value which represents the amount of interest about to be paid
uint256 interestToPayOut = expectedInterest[msg.sender];
// Make sure that contract's reserve pool has enough to service this transaction
require(interestToPayOut.add(amountToUnstake) <= token.balanceOf(address(this)), "Not enough STATE tokens in the reserve pool to pay out the interest earned, please contact owner of this contract");
// Reduce the balance of the msg.sender to reflect how much they are unstaking during this transaction
balances[msg.sender] = balances[msg.sender].sub(amountToUnstake);
// Reset the initialStakingTimestamp[msg.sender] in preparation for future rounds of interest earning from the specific user
initialStakingTimestamp[msg.sender] = 0;
// Reduce the value which represents interest owed to the msg.sender
expectedInterest[msg.sender] = expectedInterest[msg.sender].sub(interestToPayOut);
// Reduce the total amount of interest owed by this contract (to all of its users) using the appropriate amount
totalExpectedInterest = totalExpectedInterest.sub(interestToPayOut);
// Transfer staked tokens (principle) and the interest back to user's wallet
token.safeTransfer(msg.sender, interestToPayOut.add(amountToUnstake));
// Emit the event log
emit TokensUnstaked(msg.sender, amountToUnstake);
emit InterestWithdrawn(msg.sender, interestToPayOut);
}
/// @dev Allows user to unstake tokens and withdraw their interest after the correct time period has elapsed and then reinvest automatically.
/// @param token - address of the official ERC20 token which is being unlocked here.
/// Reinvests all principle and all interest earned during the most recent term
function reinvestAlreadyStakedTokensAndInterestEarned(IERC20 token) public timePeriodIsSet percentageIsSet noReentrant {
// Ensure that there is a current round of interest at play
require(initialStakingTimestamp[msg.sender] != 0, "No tokens staked at present");
// Ensure that the current time period has elapsed and that funds are ready to be unstaked
require(block.timestamp > (initialStakingTimestamp[msg.sender].add(timePeriod)), "Locking time period is still active, please try again later");
// Ensure the official ERC20 contract is being referenced
require(token == erc20Contract, "Token parameter must be the same as the erc20 contract address which was passed into the constructor");
// Ensure there is enough reserve pool for this to proceed
require(expectedInterest[msg.sender].add(balances[msg.sender]) <= token.balanceOf(address(this)), "Not enough STATE tokens in the reserve pool to pay out the interest earned, please contact owner of this contract");
uint256 newAmountToInvest = expectedInterest[msg.sender].add(balances[msg.sender]);
require(newAmountToInvest > 315360000000, "Amount to stake must be greater than 0.00000031536 ETH");
require(newAmountToInvest < MAX_INT.div(10000), "Maximum amount must be smaller, please try again");
// Transfer expected previous interest to staked state
emit TokensUnstaked(msg.sender, balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].add(expectedInterest[msg.sender]);
// Adjust totals
// Increment the total State staked
totalStateStaked = totalStateStaked.add(expectedInterest[msg.sender]);
// Decrease total expected interest for this users past stake
totalExpectedInterest = totalExpectedInterest.sub(expectedInterest[msg.sender]);
emit InterestWithdrawn(msg.sender, expectedInterest[msg.sender]);
// Reset msg senders expected interest
expectedInterest[msg.sender] = 0;
// Start a new time period
initialStakingTimestamp[msg.sender] = block.timestamp;
// Let's calculate the maximum amount which can be earned per annum (start with mul calculation first so we avoid values lower than one)
uint256 interestEarnedPerAnnum_pre = newAmountToInvest.mul(percentageBasisPoints);
// We use basis points so that Ethereum's uint256 (which does not have decimals) can have percentages of 0.01% increments. The following line caters for the basis points offset
uint256 interestEarnedPerAnnum_post = interestEarnedPerAnnum_pre.div(10000);
// Let's calculate how many wei are earned per second
uint256 weiPerSecond = interestEarnedPerAnnum_post.div(31536000);
require(weiPerSecond > 0, "Interest on this amount is too low to calculate, please try a greater amount");
// Let's calculate the release date
uint256 releaseEpoch = initialStakingTimestamp[msg.sender].add(timePeriod);
// Let's fragment the interest earned per annum down to the remaining time left on this staking round
uint256 secondsRemaining = releaseEpoch.sub(block.timestamp);
// We must ensure that there is a quantifiable amount of time remaining (so we can calculate some interest; albeit proportional)
require(secondsRemaining > 0, "There is not enough time left to stake for this current round");
// There are 31536000 seconds per annum, so let's calculate the interest for this remaining time period
uint256 interestEarnedForThisStake = weiPerSecond.mul(secondsRemaining);
// Make sure that contract's reserve pool has enough to service this transaction. I.e. there is enough STATE in this contract to pay this user's interest (not including/counting any previous end user's staked STATE or interest which they will eventually take as a pay out)
require(token.balanceOf(address(this)) >= totalStateStaked.add(totalExpectedInterest).add(interestEarnedForThisStake), "Not enough STATE tokens in the reserve pool, to facilitate this restake, please contact owner of this contract");
// Adding this user's new expected interest
totalExpectedInterest = totalExpectedInterest.add(interestEarnedForThisStake);
// Increment the new expected interest for this user (up from being reset to zero)
expectedInterest[msg.sender] = expectedInterest[msg.sender].add(interestEarnedForThisStake);
emit TokensStaked(msg.sender, newAmountToInvest);
emit InterestEarned(msg.sender, interestEarnedForThisStake);
}
/// @dev Transfer tokens out of the reserve pool (back to owner)
/// @param token - ERC20 token address.
/// @param amount of ERC20 tokens to remove.
function transferTokensOutOfReservePool(IERC20 token, uint256 amount) public onlyOwner noReentrant {
require(address(token) != address(0), "Token address can not be zero");
// This function can only access the official timelocked tokens
require(token == erc20Contract, "Token address must be ERC20 address which was passed into the constructor");
// Ensure that user funds which are due for user payout can not be removed. Only allowed to remove spare STATE (over-supply which is just sitting in the reserve pool for future staking interest calculations)
require(amount <= token.balanceOf(address(this)).sub((totalExpectedInterest.add(totalStateStaked))), "Can only remove tokens which are spare i.e. not put aside for end user pay out");
// Transfer the amount of the specified ERC20 tokens, to the owner of this contract
token.safeTransfer(owner, amount);
}
}
| Modifier* @dev Throws if time period is not set./ | modifier timePeriodIsSet() {
require(timePeriodSet == true, "Please set the time stamp first, then try again.");
_;
}
| 12,779,715 | [
1,
9829,
225,
22435,
309,
813,
3879,
353,
486,
444,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
9606,
19470,
15737,
1435,
288,
203,
3639,
2583,
12,
957,
5027,
694,
422,
638,
16,
315,
8496,
444,
326,
813,
14429,
1122,
16,
1508,
775,
3382,
1199,
1769,
203,
3639,
389,
31,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/4/0xE284112e82c284f33E5B37fbA940f2514C076338/sources/browser/yeldx/usdc_vault.sol | Transfer asset from user to this contract | function deposit(uint256 _amount) external {
require(_amount > 0, "deposit must be greater than 0");
uint256 shares = (_amount.mul(_totalSupply)).div(_getAssetAmount());
_mint(msg.sender, shares);
IERC20(assetToken).safeTransferFrom(msg.sender, address(this), _amount);
IInvestor(currentInvestor).invest(assetToken, _amount);
}
| 12,446,516 | [
1,
5912,
3310,
628,
729,
358,
333,
6835,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
225,
445,
443,
1724,
12,
11890,
5034,
389,
8949,
13,
3903,
288,
203,
565,
2583,
24899,
8949,
405,
374,
16,
315,
323,
1724,
1297,
506,
6802,
2353,
374,
8863,
203,
565,
2254,
5034,
24123,
273,
261,
67,
8949,
18,
16411,
24899,
4963,
3088,
1283,
13,
2934,
2892,
24899,
588,
6672,
6275,
10663,
203,
565,
389,
81,
474,
12,
3576,
18,
15330,
16,
24123,
1769,
203,
27699,
565,
467,
654,
39,
3462,
12,
9406,
1345,
2934,
4626,
5912,
1265,
12,
3576,
18,
15330,
16,
1758,
12,
2211,
3631,
389,
8949,
1769,
203,
565,
467,
3605,
395,
280,
12,
2972,
3605,
395,
280,
2934,
5768,
395,
12,
9406,
1345,
16,
389,
8949,
1769,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./full_match/1/0x4fE0BBc2614391AB455fc4Df27e63669d30B94Ff/sources/src/x-key/AirdropTicket.sol | / the base URI for the metadata | contract AirdropTicket is ERC721AQueryable, Ownable {
string private baseURI;
pragma solidity 0.8.20;
An NFT ticket to be used for claiming airdrops.
constructor() payable ERC721A("Airdrop Ticket", "AIRDROP") {}
function _baseURI() internal view override returns (string memory) {
return baseURI;
}
function _startTokenId() internal pure override returns (uint256) {
return 1;
}
function mintTicket(address to, uint8 nTokens) external onlyOwner {
_mint(to, nTokens);
}
function burn(uint256 tokenId) external {
_burn(tokenId, true);
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
baseURI = newBaseURI;
}
}
| 9,800,225 | [
1,
19,
326,
1026,
3699,
364,
326,
1982,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
432,
6909,
1764,
13614,
353,
4232,
39,
27,
5340,
37,
1138,
429,
16,
14223,
6914,
288,
203,
565,
533,
3238,
1026,
3098,
31,
203,
203,
203,
683,
9454,
18035,
560,
374,
18,
28,
18,
3462,
31,
203,
979,
423,
4464,
9322,
358,
506,
1399,
364,
7516,
310,
279,
6909,
16703,
18,
203,
565,
3885,
1435,
8843,
429,
4232,
39,
27,
5340,
37,
2932,
37,
6909,
1764,
22023,
3113,
315,
37,
7937,
18768,
7923,
2618,
203,
565,
445,
389,
1969,
3098,
1435,
2713,
1476,
3849,
1135,
261,
1080,
3778,
13,
288,
203,
3639,
327,
1026,
3098,
31,
203,
565,
289,
203,
203,
565,
445,
389,
1937,
1345,
548,
1435,
2713,
16618,
3849,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
404,
31,
203,
565,
289,
203,
203,
565,
445,
312,
474,
13614,
12,
2867,
358,
16,
2254,
28,
290,
5157,
13,
3903,
1338,
5541,
288,
203,
3639,
389,
81,
474,
12,
869,
16,
290,
5157,
1769,
203,
565,
289,
203,
203,
565,
445,
18305,
12,
11890,
5034,
1147,
548,
13,
3903,
288,
203,
3639,
389,
70,
321,
12,
2316,
548,
16,
638,
1769,
203,
565,
289,
203,
203,
565,
445,
26435,
3098,
12,
1080,
745,
892,
394,
2171,
3098,
13,
3903,
1338,
5541,
288,
203,
3639,
1026,
3098,
273,
394,
2171,
3098,
31,
203,
565,
289,
203,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
//Address: 0xe1fee26c5fd6c6e58cc1cc976e4eeb63b9b3e44f
//Contract name: HODLwin2Eth
//Balance: 0 Ether
//Verification Date: 2/8/2018
//Transacion Count: 1
// CODE STARTS HERE
pragma solidity ^0.4.16;
// ------------------------------------------------------------------------
// HODLwin2Eth_exchanger
// This HODL2eth exchanger contract created by the www.HODLwin.com team
// is heavily based on the tokentraderfactory created by
// JonnyLatte & BokkyPooBah 2017. released under The MIT licence.
// big appreciation and respect to those two
//
// This is a Decentralised trustless contract and when launched will only accept
// the token input at launch, in our case the HODLwin token and return ETH
// in exchange.
//
// Once it has been released on the blockchain only the rate of Ethereum
// swapped in return for the HODLwin tokens and also the owner of the contract
// can be changed.
//
// No one including the owner can turn it off or set the price below
// the original crowdsale price of the token the price can only ever be
// set higher than this public crowdsale price.
// It is intended that the only way to get Eth out of this contract is to
// exchange HODLwin tokens for it. It is also setup to receive any Eth sent
// to store for exchanging for HODLwin tokens.
//
// original code licensed under:
// Enjoy. (c) JonnyLatte & BokkyPooBah 2017. The MIT licence.
// modified code by www.HODLwin.com team
// ------------------------------------------------------------------------
contract ERC20 {
// Events ---------------------------
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// Functions ------------------------
function totalSupply() public constant returns (uint);
function balanceOf(address _owner) public constant returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint remaining);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier checkpermission{
require(msg.sender == owner && HODLwin2Eth(msg.sender).owner() == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require( _newOwner != owner );
require( _newOwner != address(0x0) );
OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// contract can buy tokens for ETH
// prices are in amount of wei per batch of token units
contract HODLwin2Eth is Owned {
address public HODLaddress; // address of token
uint256 public mktValue; // contract buys lots of token at this price
uint256 public units; // lot size (token-wei)
uint256 public origMktValue; //the original crowdsale price
event HODLrSoldWin(address indexed seller, uint256 amountOfTokensToSell,
uint256 tokensSold, uint256 etherValueOfTokensSold);
event mktValueupdated(uint _mktValue);
// Constructor - only to be called by the HODLwin2EthExchanger contract
function HODLwin2Eth (
address _HODLaddress,
uint256 _mktValue,
uint256 _units,
uint256 _origMktValue
) public {
HODLaddress = _HODLaddress;
mktValue = _mktValue;
units = _units;
origMktValue = _origMktValue;
}
// instructions for HODLr to sell Win tokens for ethers:
// 1. Calling the HODLwin approve() function with the following parameters
// _spender is the address of this contract
// _value is the number of tokens to be sold
// 2. Call the HODLrSellWin() function with the following parameter
// amountOfTokensToSell is the amount of asset tokens to be sold by
// the taker
//
// The HODLrSoldWin() event is logged with the following parameters
// seller is the seller's address
// amountOfTokensToSell is the amount of the asset tokens being
// sold by the taker
// tokensSold is the number of the asset tokens sold
// etherValueOfTokensSold is the ether value of the asset tokens sold
// Warning you cannot sell less than 1 full token only accepts 1 token or larger
function HODLrSellWin(uint256 amountOfTokensToSell) public {
// Maximum number of token the contract can buy
// Note that mktValue has already been validated as > 0
uint256 can_buy = this.balance / mktValue;
// Token lots available
// Note that units has already been validated as > 0
uint256 order = amountOfTokensToSell / units;
// Adjust order for funds available
if(order > can_buy) order = can_buy;
if(order > 0){
// Extract user tokens
require (ERC20(HODLaddress).transferFrom(msg.sender, address(this), order * units));
// Pay user
require (msg.sender.send(order * mktValue));
}
HODLrSoldWin(msg.sender, amountOfTokensToSell, order * units, order * mktValue);
}
function updatemktValue(uint _mktValue) public onlyOwner {
require(_mktValue >= origMktValue);
mktValue = _mktValue;
mktValueupdated(_mktValue);
}
// Taker buys tokens by sending ethers
function () public payable {
}
}
// This contract deploys HODLwin2Eth contracts and logs the event
contract HODLwin2EthExchanger is Owned {
event TradeListing(address indexed ownerAddress, address indexed HODLwin2EthAddress,
address indexed HODLaddress, uint256 mktValue, uint256 units, uint256 origMktValue);
mapping(address => bool) _verify;
// Anyone can call this method to verify the settings of a
// HODLwin2Eth contract. The parameters are:
// tradeContract is the address of a HODLwin2Eth contract
//
// Return values:
// valid did this HODLwin2EthExchanger create the HODLwin2Eth contract?
// owner is the owner of the HODLwin2Eth contract
// HODLaddress is the ERC20 HODLwin contract address
// mktValue is the buy price in ethers per `units` of HODLwin tokens
// units is the number of units of HODLwin tokens
// origMktValue is the original crowdsale price from the public crowdsale
//
function verify(address tradeContract) public constant returns (
bool valid,
address owner,
address HODLaddress,
uint256 mktValue,
uint256 units,
uint256 origMktValue
) {
valid = _verify[tradeContract];
require (valid);
HODLwin2Eth t = HODLwin2Eth(tradeContract);
owner = t.owner();
HODLaddress = t.HODLaddress();
mktValue = t.mktValue();
units = t.units();
origMktValue = t.origMktValue();
}
// Maker can call this method to create a new HODLwin2Eth contract
// with the maker being the owner of this new contract
//
// Parameters:
// HODLaddress is the address of the HODLwin contract
// mktValue is the buy price in ethers per `units` of HODLwin tokens
// sellPrice is the sell price in ethers per `units` of HODLwin tokens
// units is the number of units of HODLwin tokens
//
// For example, setting up the HODLwin2Eth contract for the following
// buy HODLwin tokens at a rate of 1*e15/1*e18= 0.001 ETH (1ETH=1000WIN)
// HODLaddress 0x48c80f1f4d53d5951e5d5438b54cba84f29f32a5
// mktValue 1*e15
// units 1*e18
//
// The TradeListing() event is logged with the following parameters
// ownerAddress is the Maker's address
// HODLwin2EthAddress is the address of the newly created HODLwin2Eth contract
// HODLaddress is the ERC20 HODLaddress address
// mktValue is the buy price in ethers per `units` of HODLaddress tokens
// sellPrice is the sell price in ethers per `units` of HODLaddress tokens
// unit is the number of units of HODLaddress tokens
// buysTokens is the HODLwin2Eth contract buying tokens?
// sellsTokens is the HODLwin2Eth contract selling tokens?
//
function createTradeContract(
address HODLaddress,
uint256 mktValue,
uint256 units,
uint256 origMktValue
) public returns (address trader) {
// Cannot have invalid HODLaddress
require (HODLaddress != 0x0);
// Check for ERC20 allowance function
// This will throw an error if the allowance function
// is undefined to prevent GNTs from being used
// with this HODLwin
uint256 allowance = ERC20(HODLaddress).allowance(msg.sender, this);
allowance= allowance;
// Cannot set zero or negative price
require(mktValue > 0);
// Must make profit on spread
// Cannot buy or sell zero or negative units
require(units > 0);
trader = new HODLwin2Eth(
HODLaddress,
mktValue,
units,
origMktValue
);
// Record that this HODLwin created the trader
_verify[trader] = true;
// Set the owner to whoever called the function
HODLwin2Eth(trader).transferOwnership(msg.sender);
TradeListing(msg.sender, trader, HODLaddress, mktValue, units, origMktValue);
}
//Fallback Accepts ether even accidental sending
function () public payable {
}
}
| Fallback Accepts ether even accidental sending | function () public payable {
}
| 1,076,173 | [
1,
12355,
27158,
225,
2437,
5456,
25961,
287,
5431,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
282,
445,
1832,
1071,
8843,
429,
288,
203,
377,
203,
225,
289,
203,
27699,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "./libs/BEP20.sol";
import "./libs/IGreatTengu.sol";
import "./libs/SafeBEP20.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
// TenguToken with Governance.
contract TenguToken is BEP20 {
using SafeBEP20 for IGreatTengu;
IGreatTengu public gTengu;
// Transfer tax rate in basis points. (default 8%)
uint256 public transferTaxRate = 800;
// Burn rate % of transfer tax. (default 25% x 8% = 2% of total amount).
uint256 public burnRate = 25;
// Rate % of the gTengu obtained from the transfer tax. (default 50% x 8% = 4% of total amount)
uint256 public gTenguRate = 50;
// Max transfer tax rate: 10%.
uint256 public constant MAXIMUM_TRANSFER_TAX_RATE = 1000;
// Burn address
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
// Active fee to swap GTENGU to TENGU (default is 20%)
uint256 public swapGTenguToTenguFee = 2000;
// Max fee to swap GTENGU to TENGU (30%)
uint256 public constant SWAP_GTENGU_TO_TENGU_MAX_FEE = 3000;
// List to cancel GTENGU tax to master & pools contracts
mapping(address => bool) public excludedFromGTenguTax;
// Addresses excluded from whole transfer tax
mapping(address => bool) public excludedFromTransferTax;
// Max transfer amount rate in basis points. (default is 0.5% of total supply)
uint256 public maxTransferAmountRate = 50;
// Min. transfer amount rate : 0.3% of total supply
uint256 public constant MIN_TRANSFER_AMOUNT_RATE = 30;
// Addresses that excluded from antiWhale
mapping(address => bool) private _excludedFromAntiWhale;
// Min amount to liquify. (default 50 TENGUs)
uint256 public minAmountToLiquify = 50 ether;
// The swap router, modifiable. Will be changed to TenguSwap's router when our own AMM release
IUniswapV2Router02 public tenguSwapRouter;
// The trading pair
address public tenguSwapPair;
// Not in swap and liquify
bool private _notInSwapAndLiquify = true;
// Set locker contract address
address public locker;
/**
* @notice The operator can update the transfer tax rate and its repartition
* It will be transferred to the timelock contract
*/
address private _operator;
/**
* @notice The sensitive operator can update the tenguSwapRouter and the locker address
* It will be transferred to a second timelock contract w/ a much longer duration
*/
address private _sensitiveOperator;
// Events
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
event SensitiveOperatorTransferred(address indexed previousOperator, address indexed newOperator);
event TransferTaxRateUpdated(address indexed operator, uint256 previousRate, uint256 newRate);
event BurnRateUpdated(address indexed operator, uint256 previousRate, uint256 newRate);
event GTenguRateUpdated(address indexed operator, uint256 previousRate, uint256 newRate);
event MaxTransferAmountRateUpdated(address indexed operator, uint256 previousRate, uint256 newRate);
event MinAmountToLiquifyUpdated(address indexed operator, uint256 previousAmount, uint256 newAmount);
event TenguSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity);
event SetSwapGTenguToTenguFee(uint256 previousFee, uint256 newFee);
event SwapGTenguToTengu(address indexed sender, address indexed recipient, uint256 gTenguAmount, uint256 tenguAmount);
event LockerUpdated(address previousLocker, address newLocker);
event SetGTenguContractAddress(address gTengu);
event SetExcludedFromAntiWhale(address accountAddress, bool excluded);
event SetExcludedFromGTenguTax(address accountAddress, bool excluded);
event SetExcludedFromTransferTax(address accountAddress, bool excluded);
event BuyBackAndBurn(uint256 ethAmount);
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
modifier onlySensitiveOperator() {
require(_sensitiveOperator == msg.sender, "operator: caller is not the sensitive operator");
_;
}
modifier antiWhale(address sender, address recipient, uint256 amount) {
if (maxTransferAmount() > 0) {
if (
_excludedFromAntiWhale[sender] == false
&& _excludedFromAntiWhale[recipient] == false
) {
require(amount <= maxTransferAmount(), "TENGU::antiWhale: Transfer amount exceeds the maxTransferAmount");
}
}
_;
}
modifier lockTheSwap {
require(_notInSwapAndLiquify, "TENGU::lockTheSwap: already in");
_notInSwapAndLiquify = false;
_;
_notInSwapAndLiquify = true;
}
modifier transferTaxFree {
uint256 _transferTaxRate = transferTaxRate;
transferTaxRate = 0;
_;
transferTaxRate = _transferTaxRate;
}
/**
* @notice Constructs the TenguToken contract.
*/
constructor() public BEP20("TENGU Token", "TENGU") {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
_sensitiveOperator = _msgSender();
emit SensitiveOperatorTransferred(address(0), _sensitiveOperator);
setExcludedFromAntiWhale(msg.sender, true);
setExcludedFromAntiWhale(address(0), true);
setExcludedFromAntiWhale(address(this), true);
setExcludedFromAntiWhale(BURN_ADDRESS, true);
}
/// @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);
}
/// @dev overrides transfer function to meet tokenomics of TENGU
function _transfer(address sender, address recipient, uint256 amount) internal virtual override antiWhale(sender, recipient, amount) {
if (recipient == BURN_ADDRESS || transferTaxRate == 0 || excludedFromTransferTax[sender] || excludedFromTransferTax[recipient]) {
super._transfer(sender, recipient, amount);
} else {
// default tax is 8% of every transfer
uint256 taxAmount = amount.mul(transferTaxRate).div(10000);
// default 92% of transfer sent to recipient
uint256 sendAmount = amount.sub(taxAmount);
require(amount == sendAmount + taxAmount, "TENGU::transfer: Tax value invalid");
uint256 burnAmount = taxAmount.mul(burnRate).div(100);
uint256 toGTenguAmount = taxAmount.mul(gTenguRate).div(100);
// Exclude master and pools from GTengu swap (burn instead)
if (excludedFromGTenguTax[sender]) {
burnAmount = burnAmount.add(toGTenguAmount);
toGTenguAmount = 0;
}
uint256 liquidityAmount = taxAmount.sub(burnAmount).sub(toGTenguAmount);
require(taxAmount == burnAmount + toGTenguAmount + liquidityAmount, "TENGU::transfer: Burn value invalid");
super._transfer(sender, BURN_ADDRESS, burnAmount);
// transfer on this contract the amounts to liquify and to swap to GTengu
super._transfer(sender, address(this), liquidityAmount.add(toGTenguAmount));
super._transfer(sender, recipient, sendAmount);
if (toGTenguAmount > 0) {
gTengu.swapTenguToGTengu(toGTenguAmount, sender);
}
}
}
/// @dev Swap and liquify
function swapAndLiquify() external lockTheSwap transferTaxFree {
require(address(tenguSwapRouter) != address(0), "TENGU::swapAndLiquify: Router not defined");
uint256 contractTokenBalance = balanceOf(address(this));
uint256 maxTransferAmount = maxTransferAmount();
contractTokenBalance = contractTokenBalance > maxTransferAmount ? maxTransferAmount : contractTokenBalance;
if (contractTokenBalance >= minAmountToLiquify) {
// only min amount to liquify
uint256 liquifyAmount = minAmountToLiquify;
// split the liquify amount into halves
uint256 half = liquifyAmount.div(2);
uint256 otherHalf = liquifyAmount.sub(half);
// capture the contract's current ETH balance.
// this is so that we can capture exactly the amount of ETH that the
// swap creates, and not make the liquidity event include any ETH that
// has been manually sent to the contract
uint256 initialBalance = address(this).balance;
// swap tokens for ETH
swapTokensForEth(half);
// how much ETH did we just swap into?
uint256 newBalance = address(this).balance.sub(initialBalance);
// add liquidity
addLiquidity(otherHalf, newBalance);
emit SwapAndLiquify(half, newBalance, otherHalf);
}
}
/// @dev Swap tokens for eth
function swapTokensForEth(uint256 tokenAmount) private {
// generate the tenguSwap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = tenguSwapRouter.WETH();
_approve(address(this), address(tenguSwapRouter), tokenAmount);
// make the swap
tenguSwapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
/// @dev Add liquidity
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
require(locker != address(0), "TENGU::addLiquidity: locker address must be set");
// approve token transfer to cover all possible scenarios
_approve(address(this), address(tenguSwapRouter), tokenAmount);
// add the liquidity
tenguSwapRouter.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
locker,
block.timestamp
);
}
/**
* @dev Returns the max transfer amount.
*/
function maxTransferAmount() public view returns (uint256) {
return totalSupply().mul(maxTransferAmountRate).div(10000);
}
/**
* @dev Returns the address is excluded from antiWhale or not.
*/
function isExcludedFromAntiWhale(address _account) public view returns (bool) {
return _excludedFromAntiWhale[_account];
}
// To receive BNB from tenguSwapRouter when swapping
receive() external payable {}
/**
* @dev Update the transfer tax rate.
* Can only be called by the current operator.
*/
function updateTransferTaxRate(uint256 _transferTaxRate) public onlyOperator {
require(_transferTaxRate <= MAXIMUM_TRANSFER_TAX_RATE, "TENGU::updateTransferTaxRate: Transfer tax rate must not exceed the maximum rate.");
uint256 previousTransferTaxRate = transferTaxRate;
transferTaxRate = _transferTaxRate;
emit TransferTaxRateUpdated(msg.sender, previousTransferTaxRate, transferTaxRate);
}
/**
* @dev Update the burn rate.
* Can only be called by the current operator.
*/
function updateBurnRate(uint256 _burnRate) public onlyOperator {
require(_burnRate.add(gTenguRate) <= 100, "TENGU::updateBurnRate: GTengu + burn rates must not exceed the maximum rate.");
uint256 previousBurnRate = burnRate;
burnRate = _burnRate;
emit BurnRateUpdated(msg.sender, previousBurnRate, burnRate);
}
/**
* @dev Update the burn rate.
* Can only be called by the current operator.
*/
function updateGTenguRate(uint256 _gTenguRate) public onlyOperator {
require(burnRate.add(_gTenguRate) <= 100, "TENGU::updateGTenguRate: GTengu + burn rates must not exceed the maximum rate.");
uint256 previousGTenguRate = gTenguRate;
gTenguRate = _gTenguRate;
emit GTenguRateUpdated(msg.sender, previousGTenguRate, gTenguRate);
}
/**
* @dev Update the max transfer amount rate.
* Can only be called by the current operator.
*/
function updateMaxTransferAmountRate(uint256 _maxTransferAmountRate) public onlyOperator {
require(_maxTransferAmountRate <= 50, "TENGU::updateMaxTransferAmountRate: Max transfer amount rate must not exceed the maximum rate.");
require(_maxTransferAmountRate >= MIN_TRANSFER_AMOUNT_RATE, "TENGU::updateMaxTransferAmountRate: Min transfer amount rate must be above the minimum rate.");
uint256 previousMaxTransferAmountRate = maxTransferAmountRate;
maxTransferAmountRate = _maxTransferAmountRate;
emit MaxTransferAmountRateUpdated(msg.sender, previousMaxTransferAmountRate, maxTransferAmountRate);
}
/**
* @dev Update the min amount to liquify.
* Can only be called by the current operator.
*/
function updateMinAmountToLiquify(uint256 _minAmount) public onlyOperator {
uint256 previousMinAmountToLiquify = minAmountToLiquify;
minAmountToLiquify = _minAmount;
emit MinAmountToLiquifyUpdated(msg.sender, previousMinAmountToLiquify, minAmountToLiquify);
}
/**
* @dev Exclude or include an address from antiWhale.
* Can only be called by the current operator.
*/
function setExcludedFromAntiWhale(address _account, bool _excluded) public onlyOperator {
_excludedFromAntiWhale[_account] = _excluded;
emit SetExcludedFromAntiWhale(_account, _excluded);
}
/**
* @dev Update the swap router.
* Can only be called by the current sensitiveOperator.
*/
function updateTenguSwapRouter(address _router) public onlySensitiveOperator {
tenguSwapRouter = IUniswapV2Router02(_router);
tenguSwapPair = IUniswapV2Factory(tenguSwapRouter.factory()).getPair(address(this), tenguSwapRouter.WETH());
require(tenguSwapPair != address(0), "TENGU::updateTenguSwapRouter: Invalid pair address.");
emit TenguSwapRouterUpdated(msg.sender, address(tenguSwapRouter), tenguSwapPair);
}
/**
* @dev Update the tengu locker contract.
* Can only be called by the current sensitiveOperator.
*/
function updateLocker(address _locker) public onlySensitiveOperator {
require(_locker != address(0), "TENGU::updateTenguLocker: new operator is the zero address");
address previousLocker = locker;
locker = _locker;
// Remove previous locker from anti-whale
if (address(previousLocker) != address(0)) {
setExcludedFromAntiWhale(address(previousLocker), false);
}
// Exclude new locker from anti-whale
setExcludedFromAntiWhale(address(locker), true);
emit LockerUpdated(previousLocker, locker);
}
/**
* @dev Returns the address of the current operator.
*/
function operator() public view returns (address) {
return _operator;
}
/**
* @dev Returns the address of the current sensitive operator.
*/
function sensitiveOperator() public view returns (address) {
return _sensitiveOperator;
}
/**
* @dev Transfers operator of the contract to a new account (`newOperator`).
* Can only be called by the current operator.
*/
function transferOperator(address newOperator) public onlyOperator {
require(newOperator != address(0), "TENGU::transferOperator: new operator is the zero address");
address previousOperator = _operator;
_operator = newOperator;
emit OperatorTransferred(previousOperator, _operator);
}
/**
* @dev Transfers sensitiveOperator of the contract to a new account (`newOperator`).
* Can only be called by the current sensitiveOperator.
*/
function transferSensitiveOperator(address newOperator) public onlySensitiveOperator {
require(newOperator != address(0), "TENGU::transferSensitiveOperator: new operator is the zero address");
address previousOperator = _operator;
_sensitiveOperator = newOperator;
emit SensitiveOperatorTransferred(previousOperator, _sensitiveOperator);
}
/**
* @dev Swap an amount of GTengu for the corresponding amount of newly minted Tengu. Burn the swapped GTengu.
*/
function _swapGTenguToTengu(address sender, address recipient, uint256 amount) internal {
require(amount > 0, "TENGU::swapGTenguToTengu: amount 0");
require(gTengu.balanceOf(sender) >= amount, "TENGU::swapGTenguToTengu: not enough GTENGU");
uint256 tenguAmount = getSwapGTenguToTenguAmount(amount);
_mint(recipient, tenguAmount);
gTengu.safeTransferFrom(sender, BURN_ADDRESS, amount);
emit SwapGTenguToTengu(sender, recipient, amount, tenguAmount);
}
function swapGTenguToTengu(uint256 amount) external {
_swapGTenguToTengu(msg.sender, msg.sender, amount);
}
function swapGTenguToTengu(uint256 amount, address recipient) external {
_swapGTenguToTengu(msg.sender, recipient, amount);
}
/**
* @dev Set the fee when swapping GTengu for Tengu.
* Can only be called by the current operator.
*/
function setSwapGTenguToTenguFee(uint256 fee) external onlyOperator {
require(fee <= SWAP_GTENGU_TO_TENGU_MAX_FEE, "TENGU::setSwapGTenguToTenguFee: fee too high");
uint256 previousFee = swapGTenguToTenguFee;
swapGTenguToTenguFee = fee;
emit SetSwapGTenguToTenguFee(previousFee, swapGTenguToTenguFee);
}
/**
* @dev Returns the amount of Tengu obtainable for swapping 'amount' of GTengu.
*/
function getSwapGTenguToTenguAmount(uint256 amount) public view returns (uint256 tenguAmount) {
uint256 fee = amount.mul(swapGTenguToTenguFee).div(10000);
return amount.sub(fee);
}
/**
* @dev Set the GTengu contract address.
* Can only be called by the current operator.
* Can only be called once.
*/
function setGTenguContractAddress(IGreatTengu gTengu_) external onlyOperator {
require(address(gTengu) == address(0), "TENGU::setGTenguContractAddress: already initialized");
gTengu = gTengu_;
// Exclude GTengu contract from anti-whale
setExcludedFromAntiWhale(address(gTengu), true);
// Authorize GTengu contract to transfer (to the burn address) the Tengu we want to swap to GTengu
// cf GreatTenguToken._swapToGTengu()
_approve(address(this), address(gTengu), uint256(-1));
emit SetGTenguContractAddress(address(gTengu));
}
/**
* @dev Exclude or include an address from transfer tax.
* Used for the Master and some internal project addresses
* Can only be called by the current operator.
*/
function setExcludedFromTransferTax(address _account, bool _excluded) public onlyOperator {
excludedFromTransferTax[_account] = _excluded;
emit SetExcludedFromTransferTax(_account, _excluded);
}
/**
* @dev Exclude or include an address from GTengu tax.
* Used for the Master and the Tengu pools.
* Can only be called by the current operator.
*/
function setExcludedFromGTenguTax(address _account, bool _excluded) public onlyOperator {
excludedFromGTenguTax[_account] = _excluded;
emit SetExcludedFromGTenguTax(_account, _excluded);
}
/**
* @dev To handle the BNB dust that may build up on the contract
* Use the BNB to buy back and burn TENGU
*/
function buyBackAndBurn() external onlyOperator {
// generate the tenguSwap pair path of weth -> token
address[] memory path = new address[](2);
path[0] = tenguSwapRouter.WETH();
path[1] = address(this);
uint256 ethAmount = address(this).balance;
// make the swap
tenguSwapRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethAmount}(
0, // accept any amount of TENGU
path,
BURN_ADDRESS,
block.timestamp
);
emit BuyBackAndBurn(ethAmount);
}
}
| * @dev Transfers operator of the contract to a new account (`newOperator`). Can only be called by the current operator./ | function transferOperator(address newOperator) public onlyOperator {
require(newOperator != address(0), "TENGU::transferOperator: new operator is the zero address");
address previousOperator = _operator;
_operator = newOperator;
emit OperatorTransferred(previousOperator, _operator);
}
| 5,365,429 | [
1,
1429,
18881,
3726,
434,
326,
6835,
358,
279,
394,
2236,
21863,
2704,
5592,
68,
2934,
4480,
1338,
506,
2566,
635,
326,
783,
3726,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
565,
445,
7412,
5592,
12,
2867,
394,
5592,
13,
1071,
1338,
5592,
288,
203,
3639,
2583,
12,
2704,
5592,
480,
1758,
12,
20,
3631,
315,
56,
16324,
57,
2866,
13866,
5592,
30,
394,
3726,
353,
326,
3634,
1758,
8863,
203,
203,
3639,
1758,
2416,
5592,
273,
389,
9497,
31,
203,
3639,
389,
9497,
273,
394,
5592,
31,
203,
3639,
3626,
11097,
1429,
4193,
12,
11515,
5592,
16,
389,
9497,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.